#include <cassert>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/fold.hpp>

////// implementation //////
namespace detail{

template<typename T>
struct Data{
    explicit Data(T const& d) : data(d) {}
protected:
    T data;   
};

template<typename T, typename NT, typename State, typename B>
struct DoInherit
: public State,
public B::template Impl<T, NT> {
    explicit DoInherit(T const& d) : State(d){}
};

template<typename T, typename Base>
struct Inherit{
    template<typename State, typename P>
    struct apply{
        typedef DoInherit<T, Base, State, P> type;
    };
};

}

template<typename T, typename Tag, typename Concepts>
class NewType
: public boost::mpl::fold<
    Concepts,
    detail::Data<T>,
    detail::Inherit<T, NewType<T, Tag, Concepts> >
>::type {

typedef typename 
boost::mpl::fold<
    Concepts,
    detail::Data<T>,
    detail::Inherit<T, NewType<T, Tag, Concepts> >
>::type Base;

public:
    explicit NewType(T const& d) : Base(d){}

    struct Access{
        template<typename P>
        static T& data(P* d){
            return static_cast<NewType*>(d)->data;
        }

        template<typename P>
        static T const& data(P const* d){
            return static_cast<NewType const*>(d)->data;
        }

        template<typename P>
        static NewType* this_(P* d){
            return static_cast<NewType*>(d);
        }

        template<typename P>
        static NewType* const& this_(P const* d){
            return static_cast<NewType const*>(d);
        }   
    };

    friend class DataAccess;
};


////////// some concepts ////////////
struct NonCopyable{
    template<typename T, typename NT>
    struct Impl{
        public:
            Impl(){}
        private:
            Impl(Impl const&);
    };
};

struct NonAssignable{
    template<typename T, typename NT>
    struct Impl{
        private:
            Impl& operator=(Impl const&);
    };
};

struct Conversion{
    template<typename T, typename NT>
    struct Impl{
        public:   
            operator T() const{
                return NT::Access::data(this);
            }
    };
};

struct Equality{
    template<typename T, typename NT>
    struct Impl{
        public:
            bool operator==(NT const& lhs) const{
                return NT::Access::data(this) == NT::Access::data(&lhs);
            }

            bool operator!=(NT const& lhs) const{
                return NT::Access::data(this) != NT::Access::data(&lhs);
            }
    };
};

struct Ordering{
    template<typename T, typename NT>
    struct Impl{
        public:
            bool operator< (NT const& lhs) const{
                return NT::Access::data(this) < NT::Access::data(&lhs);
            }

            bool operator<= (NT const& lhs) const{
                return NT::Access::data(this) <= NT::Access::data(&lhs);
            }

            bool operator> (NT const& lhs) const{
                return NT::Access::data(this) > NT::Access::data(&lhs);
            }

            bool operator>= (NT const& lhs) const{
                return NT::Access::data(this) >= NT::Access::data(&lhs);
            }
    };
};

struct Additive{
    template<typename T, typename NT>
    struct Impl{
        public:
            NT operator+(NT const& lhs) const{
                return NT(NT::Access::data(this) + NT::Access::data(&lhs));
            }

            NT& operator+=(NT const& lhs){
                NT::Access::data(this) += NT::Access::data(&lhs);
                return *NT::Access::this_(this);
            }
    };
};

/////////// some minor tests /////////

int main(){
    typedef boost::mpl::vector<NonCopyable, Equality, Ordering> Concepts;
    typedef NewType<unsigned int, struct IdTag, Concepts> IdType;

    IdType id1(5u);
    IdType id2(5u);
    IdType id3(10u);

    //IdType id4 = id3; // NonCopyable
    IdType id5(0u);
    id5 = id3; // but assignable
    assert(id5 == id3);
    
    //id5 = 11u; // no conversion
    //IdType id6 = 11u;    

    assert(id1 == id2);
    assert(id1 != id3);

    assert(id1 < id3);
    assert(id3 > id1); 

    typedef NewType<unsigned int, struct OtherIdTag, Concepts> OtherIdType;
    OtherIdType oid1(5u);
    //NumberType oid2 = id1; // distinct types, even with same concepts and underlying type
    //assert(oid1 == id1); // no conversion
}