#ifndef MCS_DIMENSION_TAG_HPP
#define MCS_DIMENSION_TAG_HPP

#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>

#include <boost/mpl/bool_fwd.hpp>

namespace mcs {

namespace units {

// represents single dimension exponent; e.g. dim_type -> length_tag
//                                              value_type -> Rational<4,3>  
template<typename T,typename V> 
struct dim
{
    typedef T    dim_type;
    typedef V    value_type;
};

// dim concept check
template<typename T> 
struct is_dim
{
    typedef boost::mpl::false_    type;
    
    static const bool    value = false;
};

template<typename T,typename V>
struct is_dim< dim<T,V> >
{ 
    typedef boost::mpl::true_    type;
    
    static const bool    value = true;
};

// extract dim type
template<typename T>
struct get_dim
{
    typedef typename T::dim_type    type;
};

// extract dim value
template<typename T>
struct get_value
{
    typedef typename T::value_type    type;
};

// negate a dimension
template<typename T,typename V>
struct Negate< dim<T,V> >
{
    typedef dim<T,typename Negate<V>::type>    type;
};

template<typename T,typename V1,typename V2>
struct Add< dim<T,V1>,dim<T,V2> >
{
    typedef dim<T,typename Add<V1,V2>::type>    type;
};

template<typename T,typename V1,typename V2>
struct Subtract< dim<T,V1>,dim<T,V2> >
{
    typedef dim<T,typename Subtract<V1,V2>::type>    type;
};

template<typename T,typename V,long N,long D>
struct Multiply< dim<T,V>,Rational<N,D> >
{
    typedef dim<T,typename Multiply<V,Rational<N,D> >::type>    type;
};

template<typename T,typename V,long N,long D>
struct Divide< dim<T,V>,Rational<N,D> >
{
    typedef dim<T,typename Divide<V,Rational<N,D> >::type>    type;
};

} // namespace units

} // namespace mcs

#endif // MCS_DIMENSION_TAG_HPP