IComponentType.h

 
#ifndef COSMO_COMPONENT_TYPE_INTERFACE_H
#define COSMO_COMPONENT_TYPE_INTERFACE_H
 
#include <Pt/Cosmo/IUnknown.h>
#include <Pt/Cosmo/IEnumerable.h>
 
#include <typeinfo>
 
namespace Pt {
 
namespace Cosmo {
 
class Component;
 
class IComponentType
{
  public:
      virtual ~IComponentType()
      {}
 
    bool hasFeatureId(const char* featureId) const;
 
    const IEnumerable<const char*>& featureIds() const;
 
    const char* classId() const;
 
    template <typename I>
    bool hasInterface() const;
 
    template <typename I>
    I* queryInterface(Component& c) const;
 
  protected:
    virtual bool onHasFeatureId(const char* featureId) const = 0;
    
    virtual const IEnumerable<const char*>& onGetFeatureIds() const = 0;
 
    virtual const char* onGetClassId() const = 0;
 
    virtual bool onHasInterface(const std::type_info& ti) const = 0;
 
    virtual IUnknown* onQueryInterface(Component& c, 
                                       const std::type_info& ti) const = 0;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#include <Pt/Cosmo/Component.h>
 
namespace Pt {
 
namespace Cosmo {
 
inline bool IComponentType::hasFeatureId(const char* featureId) const
{
  return onHasFeatureId(featureId);
}
 
 
inline const IEnumerable<const char*>& IComponentType::featureIds() const
{
  return onGetFeatureIds();
}
 
 
inline const char* IComponentType::classId() const
{
  return onGetClassId();
}
 
 
template <typename I>
bool IComponentType::hasInterface() const
{
  const std::type_info& ti = typeid(I);
  return onHasInterface(ti);
}
 
 
template <typename I>
I* IComponentType::queryInterface(Component& c) const
{
  const std::type_info& ti = typeid(I);
  IUnknown* unknown = onQueryInterface(c, ti);
  return static_cast<I*>(unknown);
}
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif // include guard