encfs/base/Registry.h

#ifndef REGISTRY_H
#define REGISTRY_H

#include <list>
#include <map>
#include <string>

namespace encfs {

template <typename T>
class Registry
{
public:
  typedef T *(*FactoryFn)();
  struct Data {
    FactoryFn constructor;
    typename T::Properties properties;
  };

  void Register(const char *name,  FactoryFn fn,
                typename T::Properties properties)
  {
    Data d;
    d.constructor = fn;
    d.properties = properties;
    data[name] = d;
  }

  T* Create(const char *name)
  {
    auto it = data.find(name);
    if (it == data.end())
      return NULL;
    return (*it->second.constructor)();
  }

  T* CreateForMatch(const std::string &description)
  {
    for (auto &it : data) {
      auto name = it.second.properties.toString();
      if (!name.compare(0, description.size(), description))
        return (*it.second.constructor)();
    }
    return NULL;
  }

  std::list<std::string> GetAll() const {
    std::list<std::string> result;
    for (auto &it : data) {
      result.push_back(it.first);
    }
    return result;
  }

  const typename T::Properties *GetProperties(const char *name) const {
    auto it = data.find(name);
    if (it == data.end())
      return NULL;
    return &(it->second.properties);
  }
  
  const typename T::Properties *GetPropertiesForMatch(
      const std::string &description) const {
    for (auto &it : data) {
      auto name = it.second.properties.toString();
      if (!name.compare(0, description.size(), description))
        return &(it.second.properties);
    }
    return NULL;
  }


private:
  std::map<std::string, Data> data;
};

template <typename T, typename BASE>
class Registrar
{
public:
  Registrar(const char *name)
  {
    BASE::GetRegistry().Register(name,
                                 Registrar<T, BASE>::Construct,
                                 T::GetProperties());
  }

  static BASE *Construct() {
    return new T();
  }
};

#define DECLARE_REGISTERABLE_TYPE(TYPE) \
    static Registry<TYPE>& GetRegistry()

#define DEFINE_REGISTERABLE_TYPE(TYPE) \
    Registry<TYPE>& TYPE::GetRegistry() { \
      static Registry<TYPE> registry; \
      return registry; \
    }

#define REGISTER_CLASS(DERIVED, BASE) \
    static Registrar<DERIVED, BASE> registrar_ ## DERIVED ## _ ## BASE (#DERIVED)

}  // namespace encfs

#endif // REGISTRY_H