TClassRegistration.h

Go to the documentation of this file.

#pragma once
#include <misc/gen/DynamicLibraryInfo.h>
#include <misc/gen/Exception.h>
#include <misc/gen/TClosure.h>
#include <misc/gen/TVector.h>
#include <misc/gen/dbgutils.h>
#include <misc/global.h>
 
#define SF_DL_NAME_FUNC_NAME "_dl_name_"
#define SF_DL_NAME_FUNC _dl_name_
 
#if IS_WIN
  // Select copy function which is allowed by MS Windows.
  #define SF_DL_STRING_COPY(dest, src, sz) strncpy_s(dest, sz, src, sz)
#else
  #define SF_DL_STRING_COPY(dest, src, sz) strncpy(dest, src, sz)
#endif
 
// clang-format off
#define SF_DL_INFORMATION(name, description)  \
  namespace  \
  {  \
  const char* _dl_ = SF_DL_MARKER_BEGIN name SF_DL_NAME_SEPARATOR description SF_DL_MARKER_END;  \
  \
  extern "C" TARGET_EXPORT const char* SF_DL_NAME_FUNC(const char* nm)  \
  {  \
    static char storage[256];  \
    if (nm)  \
      SF_DL_STRING_COPY(storage, nm, sizeof(storage));  \
    return storage;  \
  }  \
  }
 
extern "C" const char* SF_DL_NAME_FUNC(const char* name);
 
#define SF_DL_NAME_FUNC_TYPE const char* (*) (const char*)
 
namespace sf
{
 
inline std::string getLibraryName()
{
  return SF_DL_NAME_FUNC(nullptr);
}
 
}// namespace sf
 
#define SF_DECL_IFACE(InterfaceType, ParamType, FuncName) \
private: \
  std::string _Register_Name_; \
 \
public: \
  static sf::TClassRegistration<InterfaceType, ParamType> FuncName(); \
  friend class sf::TClassRegistration<InterfaceType, ParamType>;
 
#define SF_IMPL_IFACE(InterfaceType, ParamType, FuncName) \
  sf::TClassRegistration<InterfaceType, ParamType> InterfaceType::FuncName() \
  { \
    static sf::TClassRegistration<InterfaceType, ParamType>::entries_t entries; \
    return sf::TClassRegistration<InterfaceType, ParamType>(entries); \
  }
 
#define SF_REG_CLASS(InterfaceType, ParamType, FuncName, DerivedType, RegName, Description) \
  namespace \
  { \
  __attribute__((constructor)) void _## DerivedType## _() \
  { \
    size_t dist = InterfaceType::FuncName().registerClass( \
      RegName, Description, sf::TClassRegistration<InterfaceType, ParamType>::callback_t([](const ParamType& params) -> InterfaceType* { \
        auto inst = new DerivedType(params); \
        sf::TClassRegistration<InterfaceType, ParamType>::setRegisterName(inst, RegName); \
        return inst; \
      }) \
    ); \
  } \
  }
// clang-format on
 
namespace sf
{
 
template<typename T, typename P>
class TClassRegistration
{
  public:
    // Type and forward definitions.
    typedef TClassRegistration self_t;
    typedef TClosure<T*, const P&> callback_t;
    class entry_t;
    typedef std::vector<entry_t> entries_t;
 
    typedef TVector<std::string> strings_t;
 
    static auto constexpr npos = std::numeric_limits<size_t>::max();
 
    explicit TClassRegistration(entries_t& entries);
 
    TClassRegistration(const TClassRegistration& inst);
 
    TClassRegistration(TClassRegistration&& inst) noexcept;
 
    TClassRegistration& operator=(const TClassRegistration& inst)
    {
      // Prevent self assignment.
      if (this != &inst)
      {
        _entries = inst._entries;
      }
      return *this;
    }
 
    size_t registerClass(const char* name, const char* description, const callback_t& callback);
 
    [[nodiscard]] size_t indexOf(const std::string& name) const;
 
    T* create(const std::string& name, const P& params = P{}) const;
 
    T* create(size_t index, const P& params = P{}) const;
 
    [[nodiscard]] size_t size() const;
 
    static void setRegisterName(T* inst, const char* name)
    {
      inst->_Register_Name_ = name;
    }
 
    const std::string& getRegisterName(T* inst) const;
 
    [[nodiscard]] const char* getName(size_t index) const;
 
    [[nodiscard]] strings_t getNames() const;
 
    [[nodiscard]] const char* getDescription(size_t index) const;
 
    class entry_t
    {
      public:
        entry_t(const char* name, const char* description, const callback_t& callback);
 
        entry_t(const entry_t& e);
 
      private:
        const char* _name;
        const char* _description;
        callback_t _callback;
 
        friend class TClassRegistration;
    };
 
  private:
    const entry_t* find(const std::string& name) const;
 
    entries_t* _entries;
 
    typename entries_t::const_iterator lookup(const std::string& name) const;
};
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <misc/gen/TClassRegistration.hpp>