#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/static_assert.hpp>

#include <boost/operators.hpp>

#include <limits>
#include <cmath>

#include <iosfwd>


namespace core {

    namespace mpl = boost::mpl;

    namespace detail {

        template<typename BuiltInT>
        struct value_holder
        {
            BOOST_STATIC_ASSERT_MSG(boost::is_arithmetic<BuiltInT>::value, "T must be a fundamental type");

            typedef BuiltInT                    		builtin_type;
            typedef std::numeric_limits<builtin_type> 	limits;

            constexpr value_holder()
            { }

            template<typename T>
            constexpr value_holder(T d) : m_data(d)
            { }

            builtin_type                    m_data;
        };
    }

    template <class BuiltInT>
    struct operators
        : boost::less_than_comparable<BuiltInT,
              boost::equality_comparable<BuiltInT,
                  boost::addable<BuiltInT,
                      boost::subtractable<BuiltInT,
                          boost::multipliable<BuiltInT,
                              boost::dividable<BuiltInT
                              >
                          >
                      >
                  >
              >
          >
    { };

    ////////////////////////////////////////////////////////////////////////////
    template<typename BuiltInT>
    struct my_type
        : detail::value_holder<BuiltInT>,
          operators<my_type<BuiltInT> >
    {
        typedef detail::value_holder<BuiltInT>  base;
        typedef typename base::builtin_type 	builtin_type;

        typedef my_type<BuiltInT>               type;

        // default constructor
        constexpr my_type()
        { }

        // copy constructor
        constexpr my_type(my_type<BuiltInT> const& other)
        : base(other.m_data)
        { }

        // copy constructor
        constexpr my_type(detail::value_holder<BuiltInT> const& other)
        : base(other.m_data)
        { }

        template<typename T>
        constexpr my_type(T d)
        : base(d)
        { }

        builtin_type to_builtin() const {
            return base::m_data;
        }

        builtin_type& to_builtin() {
            return base::m_data;
        }

        bool operator<(my_type const& rhs) const {
            return to_builtin() < rhs.to_builtin();
        }

        bool operator==(my_type const& rhs) const {
            return to_builtin() == rhs.to_builtin();
        }

        my_type operator+=(my_type const& rhs) {
            to_builtin() += rhs.to_builtin();
            return *this;
        }

        my_type operator-=(my_type const& rhs) {
            to_builtin() -= rhs.to_builtin();
            return *this;
        }

        my_type operator*=(my_type const& rhs) {
            to_builtin() *= rhs.to_builtin();
            return *this;
        }

        my_type operator/=(my_type const& rhs) {
            to_builtin() /= rhs.to_builtin();
            return *this;
        }

        my_type operator-() const {
            return my_type(-to_builtin());
        }

       template<typename CharT>
        std::basic_ostream<CharT>& print_on(std::basic_ostream<CharT>& os) const {
            os << to_builtin();
            return os;
        }
    };


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

		template<typename BuiltInT>
		struct sqrt
		{
			typedef my_type<BuiltInT> 				source_type;
			typedef typename source_type::builtin_type		builtin_type;

			static inline
			source_type apply(source_type const& value) {

				// XXX type promotion; rounding
				return std::sqrt(value.to_builtin());

			}
		};

    } // detail

    template <typename BuiltInT>
    static inline
    my_type<BuiltInT>
    sqrt(my_type<BuiltInT> const& value) {
    	return detail::sqrt<BuiltInT>::apply(value);
    }

    ////////////////////////////////////////////////////////////////////////////
    template<typename CharT, typename BuiltInT>
    static inline
    std::basic_ostream<CharT>& operator<<(std::basic_ostream<CharT>& os, my_type<BuiltInT> const& v) {
        return v.print_on(os);
    }
}


////////////////////////////////////////////////////////////////////////////////
namespace kernel {

	template <typename T>
	struct point
	{
		typedef core::my_type<T>				coordiante_type;

		coordiante_type								x, y;
	};
}

typedef kernel::point<double> point_type;
typedef kernel::point<double>::coordiante_type 		coordinate_type;

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/register/point.hpp>
#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>

namespace bg = boost::geometry;

// XXX BOOST_GEOMETRY_REGISTER_POINT_2D(point_type, point_type::coordiante_type, bg::cs::cartesian, x, y)
BOOST_GEOMETRY_REGISTER_POINT_2D(kernel::point<double>, kernel::point<double>::coordiante_type, bg::cs::cartesian, x, y)


int main()
{
	point_type p1, p2;

    bg::assign_values(p1, 1, 1);
    bg::assign_values(p2, 2, 2);

    coordinate_type d = bg::distance(p1, p2);

    std::cout << "Distance: " << d << std::endl;

}