//PropertyType.h 소스 일부분

enum ePropertyType

{

    ept_bool,

    ept_DWORD,

    ept_int,

    ept_float,

    ept_string,

    ept_ptr,

    eptMAX_PROPERTY_TYPES

};

 

template <class T> class PropertyType

{

public :

    // Returns type ID associated with the templatized type.

    static    ePropertyType    GetTypeID()

    {

        return ms_typeID;

    }

    static    char*            GetTypeName()

    {

        return ms_typeName;

    }

 

private:

    static    ePropertyType        ms_typeID;

    static  char*                ms_typeName;

};

 

template<class T> ePropertyType PropertyType<T>::ms_typeID        = ept_ptr;

template<class T> char*            PropertyType<T>::ms_typeName    = "ptr";

 

template<> ePropertyType PropertyType<bool>::ms_typeID            = ept_bool;

template<> char*        PropertyType<bool>::ms_typeName        = "bool";

 

template<> ePropertyType PropertyType<DWORD>::ms_typeID            = ept_DWORD;

template<> char*        PropertyType<DWORD>::ms_typeName        = "DWORD";

 

template<> ePropertyType PropertyType<int>::ms_typeID            = ept_int;

template<> char*        PropertyType<int>::ms_typeName            = "int";

 

template<> ePropertyType PropertyType<float>::ms_typeID            = ept_float;

template<> char*        PropertyType<float>::ms_typeName        = "float";

 

template<> ePropertyType PropertyType<char*>::ms_typeID            = ept_string;

template<> char*        PropertyType<char*>::ms_typeName        = "string";

#include <string>

#include "PropertyType.h"

 

//인터페이스는 템플릿을 사용하지 않음으로써 Property를 컨테이너에 담을수 있다.

class IProperty

{

public:

    IProperty( const std::string& name ) : m_name( name )

    {

    }

    virtual ~IProperty()

    {

    }

    const std::string& GetName()

    {

        return m_name;

    }

    virtual char*    GetTypeName() const = 0;

    virtual ePropertyType    GetType() const = 0;

    virtual void*            GetData() = 0;

protected:

    std::string        m_name;

};

 

template<typename T>

class MyProperty : public IProperty

{

public:

    MyProperty( const std::string& name ) : IProperty( name )

    {

    }

    virtual ~MyProperty()

    {

    }

    ePropertyType GetType() const

    {

        return PropertyType<T>::GetTypeID();

    }

    char*    GetTypeName() const

    {

        return PropertyType<T>::GetTypeName();

    }

    virtual void* GetData()

    {

        return &m_data;

    }

    T& GetValue()

    {

        return m_data;

    }

 

protected:

    T    m_data;

};

    //MyProperty 테스트

    MyProperty<float>* pValue = new MyProperty<float>("Health");

    pValue->GetValue() = 3.03f;

    std::cout << pValue->GetName() << "=" << pValue->GetValue() << std::endl;

    const char* szType = pValue->GetTypeName();  //float 형

 

     실행 결과 :  Health=3.03                 

class CPlayer : public MyPropertySystem

{

public:

    CPlayer()

    {

        GetPropertyValue<int>("Damage") = 100;   //Damage라는 속성을 추가한다.

    }

};

    //클래스에 MyProperty 적용한 사용법

    CPlayer player;

    IProperty* prop = player.GetProperty("Damage");

    int nDamage = player.GetPropertyValue<int>("Damage");

    std::cout << "CPlayer " << prop->GetName() << " " << prop->GetTypeName() << " " << nDamage << std::endl;

 

          실행 결과 : CPlayer Damage int 100