ComponentPlugin.h

 
#ifndef COSMO_COMPONENT_PLUGIN_H
#define COSMO_COMPONENT_PLUGIN_H
 
#include <Pt/Cosmo/ComponentMode.h>
#include <Pt/Cosmo/Enumerable.h>
#include <Pt/Cosmo/AutoReleasePool.h>
#include <Pt/Cosmo/IComponentPlugin.h>
 
#include <string>
#include <vector>
#include <map>
#include <typeindex>
#include <typeinfo>
 
namespace Pt {
 
namespace Cosmo {
 
class Component;
class IComponentManager;

template <typename T>
class ComponentFactory
{
  public:
    ComponentFactory()
    {}

    Component* create()
    {
      return new T();
    }

    void destroy(Component* instance)
    {
      delete instance;
    }
};

template <typename T>
class FromReference
{
  public:
    explicit FromReference(T& instance)
    : _instance(&instance)
    {}
 
    Cosmo::Component* create()
    { return _instance; }
 
    void destroy(Cosmo::Component* /*instance*/)
    {}
 
  private:
    T* _instance;
};

template <typename T, typename Factory = ComponentFactory<T> >
class ComponentPlugin : public IComponentPlugin
{
  public:
    class IdListEnumeration : public IEnumeration<const char*>
    {
      public:
        IdListEnumeration(const std::vector<std::string>& list)
        : _list(list)
        , _it( list.begin() )
        { }
 
      protected:
        virtual bool onIsValid() const override
        {
          return _it != _list.end();
        }
 
        virtual void onAdvance() override
        {
          ++_it;
        }
 
        virtual const char* onGet() const override
        {
          return _it->c_str();
        }
 
      private:
        const std::vector<std::string>&                   _list;
        typename std::vector<std::string>::const_iterator _it;
    };
 
    class IdList : public IEnumerable<const char*>
    {
      public:
        IdList(IAutoReleasePool& pool,
               const std::vector<std::string>& strings)
        : _pool(pool)
        , _strings(strings)
        { }
 
      protected:
        Cosmo::Enumerator<const char*> onEnumerate() const
        {
          IdListEnumeration* e = new IdListEnumeration(_strings);
          return Cosmo::Enumerator<const char*>(_pool, e);
        }
 
      private:
        IAutoReleasePool&                _pool;
        const std::vector<std::string>&  _strings;
    };
 
  public:
    ComponentPlugin(const char* featureId, const char* info,
                    ComponentMode mode = ComponentMode::None,
                    const Factory& factory = ComponentFactory<T>());

    ComponentPlugin(const char* featureId, const char* classId, const char* info,
                    ComponentMode mode = ComponentMode::None,
                    const Factory& factory = ComponentFactory<T>());

    ~ComponentPlugin();

    template <typename I>
    void registerInterface();

    template <typename I>
    void registerInterface( I* (T::*getter)() );

    void registerDependency(const char* featureId);

    void registerFeatureId(const char* featureId);
 
  protected:
    // inherit docs
    virtual bool onHasFeatureId(const char* featureId) const override;
 
    // inherit docs
    virtual const IEnumerable<const char*>& onGetFeatureIds() const override;
 
    // inherit docs
    virtual const char* onGetClassId() const override;
 
    // inherit docs
    bool onHasInterface(const std::type_info& ti) const override;
 
    // inherit docs
    virtual IUnknown* onQueryInterface(Component& c,
                                       const std::type_info& ti) const override;
 
  protected:
    // inherit docs
    virtual void onAttach(IComponentManager& cm,
                          const std::string& instance) override;
 
    // inherit docs
    virtual void onDetach(IComponentManager& cm,
                          const std::string& instance) override;
 
    // inherit docs
    virtual void onDetach(IComponentManager& cm) override;
 
    // inherit docs
    virtual const IEnumerable<const char*>& onGetDependencies() const override;
 
    // inherit docs
    virtual ComponentMode onGetMode() const override;
 
    // inherit docs
    virtual const char* onGetInfo() const override;
 
    // inherit docs
    virtual Component* onCreate() override;
 
    // inherit docs
    virtual void onDestroy(Component* instance) override;
 
  private:
    class IThunk;
 
    template <typename I>
    class GetAggregated;
 
    template <typename I>
    class GetInherited;
 
    typedef std::map<std::type_index, IThunk*> ThunkMap;
    ThunkMap _thunks;
 
    Factory                   _factory;
    std::string               _classId;
    std::vector<std::string>  _featureIds;
    std::string               _info;
    ComponentMode             _mode;
    std::vector<std::string>  _dependencies;
 
    std::multimap<IComponentManager*,
                  std::string>        _componentManager;
 
    AutoReleasePool _pool;
    IdList          _featureIdsEnum;
    IdList          _dependenciesEnum;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#include <Pt/Cosmo/ComponentPlugin.tpp>
 
#endif