fileformatfactory.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/list.h>
#include <promeki/result.h>
#include <promeki/logger.h>
#include <promeki/util.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class IODevice;
 
template <typename Product> class FileFormatFactory {
        public:
                struct Context {
                                int       operation = 0;    
                                String    filename;         
                                String    formatHint;       
                                IODevice *device = nullptr; 
                };
 
                static int registerFactory(FileFormatFactory *factory) {
                        if (factory == nullptr) return -1;
                        auto &list = factoryList();
                        int   ret = list.size();
                        promekiLog(Logger::LogLevel::Debug, "Registered FileFormatFactory %s", factory->name().cstr());
                        // Adopt the factory so the list owns it; otherwise
                        // every PROMEKI_REGISTER_FILE_FORMAT_FACTORY(new Foo)
                        // would leak a pointer for the lifetime of the process.
                        list.pushToBack(UniquePtr<FileFormatFactory>::takeOwnership(factory));
                        return ret;
                }
 
                static const FileFormatFactory *lookup(const Context &ctx) {
                        auto &list = factoryList();
                        for (const auto &f : list) {
                                if (f->canDoOperation(ctx)) return f.get();
                        }
                        return nullptr;
                }
 
                FileFormatFactory() = default;
 
                virtual ~FileFormatFactory() {}
 
                String name() const { return _name; }
 
                const StringList &extensions() const { return _exts; }
 
                bool isExtensionSupported(const String &filename) const {
                        size_t dot = filename.rfind('.');
                        if (dot == String::npos || dot + 1 >= filename.size()) return false;
                        String ext = filename.mid(dot + 1).toLower();
                        for (const auto &item : _exts) {
                                if (ext == item) return true;
                        }
                        return false;
                }
 
                bool isHintSupported(const String &hint) const {
                        String lower = hint.toLower();
                        for (const auto &item : _exts) {
                                if (lower == item) return true;
                        }
                        return false;
                }
 
                virtual bool canDoOperation(const Context &ctx) const { return false; }
 
                virtual Result<Product> createForOperation(const Context &ctx) const {
                        return makeError<Product>(Error::NotImplemented);
                }
 
        protected:
                String     _name; 
                StringList _exts; 
 
        private:
                static List<UniquePtr<FileFormatFactory>> &factoryList() {
                        static List<UniquePtr<FileFormatFactory>> list;
                        return list;
                }
};
 
#define PROMEKI_REGISTER_FILE_FORMAT_FACTORY(product, name)                                                            \
        [[maybe_unused]] static int PROMEKI_CONCAT(__promeki_fff_, PROMEKI_UNIQUE_ID) =                                \
                FileFormatFactory<product>::registerFactory(new name);
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE