#ifndef PROPERTY_HPP
#define PROPERTY_HPP

template <class PARAM>
class UndefinedCallback
{
    public:
        virtual void operator () (PARAM) = 0;
};

template <class PARAM>
class FunctionCallback
    : public UndefinedCallback<PARAM>
{
private:
    typedef void (*FUNCTION) (PARAM);
    FUNCTION m_pFunction;

public:
    FunctionCallback(FUNCTION pFunction)
    {
        m_pFunction = pFunction;
    }

    inline void operator () (PARAM arg)
    {
        return (*m_pFunction) (arg);
    }
};

template <class CLASS, class PARAM>
class MemberCallback
    : public UndefinedCallback<PARAM>
{
private:
    typedef void (CLASS::*FUNCTION) (PARAM);

    FUNCTION m_pFunction;
    CLASS* m_pObj;
public:
    MemberCallback(CLASS* pObj, FUNCTION pFunction)
    {
        m_pObj = pObj;
        m_pFunction = pFunction;
    }

    inline void operator () (PARAM arg)
    {
        return (m_pObj->*m_pFunction) (arg);
    }
};

template <class PARAM>
class Property
{
private:
    UndefinedCallback<PARAM>* m_pCallback;

public:
    Property()
    {
        m_pCallback = NULL;
    }

    virtual ~Property()
    {
        if (m_pCallback)
            delete m_pCallback;
    }

    template <class CLASS> void Connect(CLASS* pObj, void (CLASS::*pFunction) (PARAM))
    {
        if (m_pCallback)
            delete m_pCallback;

        m_pCallback = new MemberCallback<CLASS, PARAM>(pObj, pFunction);
    }

    void Connect(void (*pFunction) (PARAM))
    {
        if (m_pCallback)
            delete m_pCallback;

        m_pCallback = new FunctionCallback<PARAM>(pFunction);
    }

    void Disconnect()
    {
        if (m_pCallback)
            delete m_pCallback;

        m_pCallback = NULL;
    }

    inline void operator () (PARAM arg)
    {
        if (m_pCallback)
            (*m_pCallback) (arg);
    }
};

class NilType
{
};

#endif