IComponentPlugin.h

 
#ifndef COSMO_COMPONENT_PLUGIN_INTERFACE_H
#define COSMO_COMPONENT_PLUGIN_INTERFACE_H
 
#include <Pt/Cosmo/ComponentMode.h>
#include <Pt/Cosmo/IComponentType.h>
#include <Pt/Cosmo/IEnumerable.h>
 
namespace Pt {
 
namespace Cosmo {
 
class Component;
class IComponentManager;
 
class IComponentPlugin : public IComponentType
{
  friend class IComponentManager;
 
  public:
      virtual ~IComponentPlugin()
      {}
 
    const IEnumerable<const char*>& dependencies() const;
 
    ComponentMode mode() const;
 
    const char* info() const;
 
    Component* create(const IComponentDeclaration* decl);
 
    void destroy(Component* instance);
 
  protected:
    virtual void onAttach(IComponentManager& cm, const std::string& instance) = 0;
 
    virtual void onDetach(IComponentManager& cm, const std::string& instance) = 0;
 
    virtual void onDetach(IComponentManager& cm) = 0;
 
    virtual const IEnumerable<const char*>& onGetDependencies() const = 0;
 
    virtual ComponentMode onGetMode() const = 0;
 
    virtual const char* onGetInfo() const = 0;
 
    virtual Component* onCreate() = 0;
 
    virtual void onDestroy(Component* instance) = 0;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#include <Pt/Cosmo/Component.h>
 
namespace Pt {
 
namespace Cosmo {
 
inline const IEnumerable<const char*>& IComponentPlugin::dependencies() const
{
  return onGetDependencies();
}
 
 
inline ComponentMode IComponentPlugin::mode() const
{
  return onGetMode();
}
 
 
inline const char* IComponentPlugin::info() const
{
  return onGetInfo();
}
 
 
inline Component* IComponentPlugin::create(const IComponentDeclaration* decl)
{
  Component* component = this->onCreate();
  component->init(this, decl);
  return component;
}
 
 
inline void IComponentPlugin::destroy(Component* instance)
{
  onDestroy(instance);
}
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif