Manager.h

#include <QObject>
 
#include "Forward.h"
#include <knowCore/Global.h>
 
namespace kDBBaseKnowledge
{
  class Manager : public QObject
  {
  public:
    Manager(const knowCore::WeakReference<kDB::Repository::Connection>& _connection);
    ~Manager();
    knowCore::ReturnVoid addDirectory(const QString& _directory);
    knowCore::ReturnVoid addFile(const QString& _file);
    static void addDirectoryToAll(const QString& _directory);
    static void addFileToAll(const QString& _file);
    static void registerFileLoader(Interfaces::FileLoader* _fileLoader);
    static void ignoreMimeType(const QString& _mime);
    template<typename... _TArgs_>
    static void ignoreMimeTypes(const QString& _mime, const _TArgs_&... _args);
  private:
    static void ignoreMimeTypes();
    struct Private;
    Private* const d;
  };
 
  template<typename... _TArgs_>
  inline void Manager::ignoreMimeTypes(const QString& _mime, const _TArgs_&... _args)
  {
    ignoreMimeType(_mime);
    ignoreMimeTypes(_args...);
  }
  inline void Manager::ignoreMimeTypes() {}
 
}
 
#define __KDB_REGISTER_BASE_KNOWLEDGE_FILE_LOADER(_NAME_, _KLASS_)                                  \
  namespace {                                                                                       \
    class _NAME_                                                                                    \
    {                                                                                               \
      _NAME_()                                                                                      \
      {                                                                                             \
        kDBBaseKnowledge::Manager::registerFileLoader(new _KLASS_);                                 \
      }                                                                                             \
      static _NAME_ instance;                                                                       \
    };                                                                                              \
    _NAME_ _NAME_::instance;                                                                        \
  }
 
#define KDB_REGISTER_BASE_KNOWLEDGE_FILE_LOADER(_KLASS_)                                            \
  __KDB_REGISTER_BASE_KNOWLEDGE_FILE_LOADER(__KNOWCORE_UNIQUE_STATIC_NAME(FileLoaderRegister), _KLASS_)
 
#define __KDB_REGISTER_BASE_KNOWLEDGE_IGNORE_MIME_TYPE(_NAME_, ...)                                 \
  namespace {                                                                                       \
    class _NAME_                                                                                    \
    {                                                                                               \
      _NAME_()                                                                                      \
      {                                                                                             \
        kDBBaseKnowledge::Manager::ignoreMimeTypes(__VA_ARGS__);                                    \
      }                                                                                             \
      static _NAME_ instance;                                                                       \
    };                                                                                              \
    _NAME_ _NAME_::instance;                                                                        \
  }
 
#define KDB_REGISTER_BASE_KNOWLEDGE_IGNORE_MIME_TYPE(...) \
  __KDB_REGISTER_BASE_KNOWLEDGE_IGNORE_MIME_TYPE(__KNOWCORE_UNIQUE_STATIC_NAME(IgnoreMimetypeRegster), __VA_ARGS__)