D:/Programming/GUI Editor (Source)/Property.h

//
// (C) Copyright Anders Dalvander 2003.
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//

class property_void {};

template <typename OwnerType, typename ValueType>
class getter;

template <typename OwnerType, typename ValueType>
class setter;

template <typename OwnerType, typename ValueType, typename Property1Type, typename Property2Type = property_void>
class CProperty;

template <typename OwnerType, typename ValueType>
class CPropertyBase
{
public:
        typedef OwnerType owner_type;
        typedef ValueType value_type;
        typedef getter<owner_type, value_type> getter_type;
        typedef setter<owner_type, value_type> setter_type;
        typedef CProperty<owner_type, value_type, getter_type, setter_type> readwrite_property_type;
        typedef CProperty<owner_type, value_type, getter_type> readonly_property_type;
        typedef CProperty<owner_type, value_type, setter_type> writeonly_property_type;

        friend getter_type;
        friend setter_type;

        CPropertyBase(owner_type* owner_)
                : owner(owner_)
        {
        }

private:
        owner_type* owner;
};

template <typename OwnerType, typename ValueType>
class getter
{
public:
        typedef OwnerType owner_type;
        typedef ValueType value_type;
        typedef value_type (OwnerType::*getter_func_type)() const;
        typedef CPropertyBase<owner_type, value_type> CPropertyBase_type;

        getter(CPropertyBase_type* CPropertyBase_, getter_func_type getter_func_)
                : CPropertyBase(CPropertyBase_),
                getter_func(getter_func_)
        {
        }

        value_type get_value() const
        {
                return (*CPropertyBase->owner.*getter_func)();
        }

private:
        CPropertyBase_type* CPropertyBase;
        getter_func_type getter_func;
};

template <typename OwnerType, typename ValueType>
class setter
{
public:
        typedef OwnerType owner_type;
        typedef ValueType value_type;
        typedef void (OwnerType::*setter_func_type)(value_type);
        typedef CPropertyBase<owner_type, value_type> CPropertyBase_type;

        setter(CPropertyBase_type* CPropertyBase_, setter_func_type setter_func_)
                : CPropertyBase(CPropertyBase_),
                setter_func(setter_func_)
        {
        }

        void set_value(const value_type& rhs)
        {
                (*CPropertyBase->owner.*setter_func)(rhs);
        }

private:
        CPropertyBase_type* CPropertyBase;
        setter_func_type setter_func;
};

template <typename OwnerType, typename ValueType, typename Property1Type, typename Property2Type = property_void>
class CProperty : public CPropertyBase<OwnerType, ValueType>, private Property1Type, private Property2Type
{
public:
        typedef OwnerType owner_type;
        typedef ValueType value_type;
        typedef Property1Type property1_type;
        typedef Property2Type property2_type;
        typedef CPropertyBase<owner_type, value_type> CPropertyBase_type;
        typedef CProperty<owner_type, value_type, property1_type, property2_type> this_type;

        CProperty(owner_type* owner_, property1_type property1_)
                : CPropertyBase_type(owner_),
                property1_type(property1_)
        {
        }

        CProperty(owner_type* owner_, property1_type property1_, property2_type property2_)
                : CPropertyBase_type(owner_),
                property1_type(property1_),
                property2_type(property2_)
        {
        }

        const value_type& operator=(const value_type& rhs)
        {
                set_value(rhs);
                return rhs;
        }

        operator value_type()
        {
                return get_value();
        }

        value_type operator++()
        {
                set_value(get_value() + 1);
                return get_value();
        }

        value_type operator++(int)
        {
                const value_type value = get_value();
                set_value(value + 1);
                return value;
        }

        value_type operator--()
        {
                set_value(get_value() - 1);
                return get_value();
        }

        value_type operator--(int)
        {
                const value_type value = get_value();
                set_value(value + 1);
                return value;
        }

        template <typename rhs_type>
                value_type operator+=(const rhs_type& rhs)
        {
                set_value(get_value() + rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator-=(const rhs_type& rhs)
        {
                set_value(get_value() - rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator*=(const rhs_type& rhs)
        {
                set_value(get_value() * rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator/=(const rhs_type& rhs)
        {
                set_value(get_value() / rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator%=(const rhs_type& rhs)
        {
                set_value(get_value() % rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator<<=(const rhs_type& rhs)
        {
                set_value(get_value() << rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator>>=(const rhs_type& rhs)
        {
                set_value(get_value() >> rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator^=(const rhs_type& rhs)
        {
                set_value(get_value() ^ rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator&=(const rhs_type& rhs)
        {
                set_value(get_value() & rhs);
                return get_value();
        }

        template <typename rhs_type>
                value_type operator|=(const rhs_type& rhs)
        {
                set_value(get_value() | rhs);
                return get_value();
        }

private:
        CProperty(const this_type& rhs);
        const this_type& operator=(const this_type& rhs);
};

---