/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Vicente J. Botet Escriba 2010.
// Distributed under the Boost
// Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or
// copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/stm for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_PROPERTY__HPP
#define BOOST_PROPERTY__HPP

#include <boost/config.hpp>

namespace boost {
template <typename Final, typename T
    , T(Final::* Getter)() const>
class ro_property
{
protected:
    Final const & that_;
    Final & that() {return const_cast<Final&>(that_);}
public:
    typedef T value_type;
    //-----------------------------------------------------------------------------
    ro_property(Final const& that) : that_(that) {}

    ro_property(ro_property const& r) : that_(r.that_) {}
    template<typename F, typename U,T(F::* G)()>
    ro_property(ro_property<F,U,G> const& r) : that_(r.that_) {}
               
    operator T() const {
        //T(Final::* get)()=Getter;
        return (that_.*Getter)(); 
    }
};


template <typename Final, typename T
    , T(Final::* Getter)() const,  void(Final::* Setter)(T const&)>
class rw_property : public ro_property<Final, T, Getter>
{
    typedef ro_property<Final, T, Getter> base_type;
public:
    typedef T value_type;
    //-----------------------------------------------------------------------------
    rw_property(Final & that) : base_type(that) {}

    rw_property(rw_property const& r) : base_type(r) {}

    template<typename F, typename U, U(F::* G)(),  void(F::* S)(U&)>
    rw_property(rw_property<F,U,G,S> const& r) : base_type(r) {}
        
    rw_property& operator=(T const& rhs) {
        (this->that().*Setter)(rhs);
        return *this;
    }

    template<typename U>
    rw_property& operator=(U const& rhs) {
        (this->that().*Setter)(rhs);
        return *this;
    }


};

template <typename Final, typename T
    , T(Final::* Getter)() const,  void(Final::* Setter)(T const&)
>
struct rw_property_traits {
    typedef rw_property<Final, T, Getter, Setter> reference;
    typedef rw_property<Final, T, Getter, Setter> value;
};

template <typename Final, typename T
    , T(Final::* Getter)() const
>
struct ro_property_traits {
    typedef ro_property<Final, T, Getter> value;
};

}

#define BOOST_RW_PROPERTY(FINAL, T, FIELD) \
    typedef boost::rw_property_traits<FINAL, T, &FINAL::BOOST_JOIN(get_,FIELD), &FINAL::BOOST_JOIN(set_,FIELD)> BOOST_JOIN(FIELD,_type); \
    BOOST_JOIN(FIELD,_type)::reference FIELD() { return BOOST_JOIN(FIELD,_type)::reference(*this); } \
    BOOST_JOIN(FIELD,_type)::value::value_type FIELD() const { return T(BOOST_JOIN(FIELD,_type)::value(*const_cast<FINAL*>(this))); } \

#define BOOST_RO_PROPERTY(FINAL, T, FIELD) \
    typedef boost::ro_property_traits<FINAL, T, &FINAL::BOOST_JOIN(get_,FIELD)>   BOOST_JOIN(FIELD,_type); \
    BOOST_JOIN(FIELD,_type)::value::value_type FIELD() const { return T(BOOST_JOIN(FIELD,_type)::value(*this)); } \

#define BOOST_RW_PROPERTY_STORAGE(FINAL, T, FIELD) \
private:\
    T BOOST_JOIN(FIELD,_); \
public:\
    T& FIELD() { return BOOST_JOIN(FIELD,_); } \
    T FIELD() const { return BOOST_JOIN(FIELD,_); } \

#define BOOST_RO_PROPERTY_STORAGE(FINAL, T, FIELD) \
private:\
    T BOOST_JOIN(FIELD,_); \
public:\
    T FIELD() const { return BOOST_JOIN(FIELD,_); } \


#endif //BOOST_PROPERTY__HPP