// (C) Copyright Jonathan Turkanis 2004.
// 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.

// Disclaimer: Not a Boost library.

#ifndef BOOST_IOSTREAMS_DETAIL_TUPLE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_TUPLE_HPP_INCLUDED

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

#include <utility>
#include <boost/array.hpp>
#include <boost/iostreams/detail/format_lite_config.hpp> // tuple max arity.
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/rational.hpp>
#include <boost/static_assert.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/utility/enable_if.hpp>

namespace boost { namespace io { 

//namespace detail {
//
//template<typename T>
//struct is_tuple_like_impl : mpl::false_ { };
//
//template<typename T>
//struct tuple_size_impl : mpl::int_<1> { };
//
//} // End namespace detail.

template<typename T>
struct is_tuple_like : mpl::false_ { };

template<typename T>
struct tuple_size : mpl::int_<1> { };

template<int N, typename T>
struct tuple_element { 
    typedef T type;
};

//template<int N, typename T>
//typename 
//disable_if<
//    is_tuple_like<T>, 
//    typename add_reference<T>::type 
//>::type 
//tuple_get(T& t) 
//{ 
//    BOOST_STATIC_ASSERT(N == 0);
//    return t; 
//}

template<int N, typename T>
typename 
disable_if<
    is_tuple_like<T>, 
    typename 
    add_reference<
        const typename remove_reference<T>::type
    >::type 
>::type
tuple_get(const T& t) 
{ 
    BOOST_STATIC_ASSERT(N == 0);
    return t; 
}

////------------------Definition of tuple operations for arrays-----------------//
//
//template<typename T, std::size_t N>
//struct is_tuple_like< T[N] > : mpl::true_ { };
//
//template<typename T, std::size_t N>
//struct tuple_size< T[N] > : mpl::int_<N> { };
//
//template<int N, typename T, std::size_t M>
//T& tuple_get(T (&ar)[M])
//{ 
//    BOOST_STATIC_ASSERT(N < M);
//    return ar[N]; 
//}
//
//template<int N, typename T, std::size_t M>
//struct tuple_element< N, T[M] > { 
//    BOOST_STATIC_ASSERT(N < M);
//    typedef T type;
//};

//------------------Definition of tuple operations for std::pair--------------//

namespace detail {

template<int N>
struct get_pair_element;

template<>
struct get_pair_element<0> {
    template<typename First, typename Second>
    static typename add_reference<First>::type 
    execute(std::pair<First, Second>& p)
    { return p.first; }

    template<typename First, typename Second>
    static typename add_reference<const First>::type 
    execute(const std::pair<First, Second>& p)
    { return p.first; }
};

template<>
struct get_pair_element<1> {
    template<typename First, typename Second>
    static typename add_reference<Second>::type 
    execute(std::pair<First, Second>& p)
    { return p.second; }

    template<typename First, typename Second>
    static typename add_reference<const Second>::type 
    execute(const std::pair<First, Second>& p)
    { return p.second; }
};

} // end namespace detail.

template<typename First, typename Second>
struct is_tuple_like< std::pair<First, Second> > : mpl::true_ { };

template<typename First, typename Second>
struct tuple_size< std::pair<First, Second> > : mpl::int_<2> { };

template<int N, typename First, typename Second>
typename 
mpl::if_<
    mpl::bool_<N>,
    typename add_reference<Second>::type,
    typename add_reference<First>::type
>::type 
tuple_get(std::pair<First, Second>& p)
{ 
    return detail::get_pair_element<N>::execute(p);
}

template<int N, typename First, typename Second>
typename 
mpl::if_<
    mpl::bool_<N>,
    typename add_reference<const Second>::type,
    typename add_reference<const First>::type
>::type 
tuple_get(const std::pair<First, Second>& p)
{ 
    BOOST_STATIC_ASSERT(N == 0 || N == 1);
    return detail::get_pair_element<N>::execute(p);
}

template<int N, typename First, typename Second>
struct tuple_element< N, std::pair<First, Second> > 
    : mpl::if_c<N, Second, First> 
{ BOOST_STATIC_ASSERT(N == 0 || N == 1); };
                    
////------------------Definition of tuple operations for std::complex-----------//
//
//namespace detail {
//
//template<typename T>
//class complex_real {
//public:
//    complex_real(std::complex<T>& c) : c(c) { }
//    operator T() const { return c.real(); }
//    void operator=(T t) { c = std::complex<T>(t, c.imag()); }
//private:
//    std::complex<T>& c;
//};
//
//template<typename T>
//class complex_imag {
//public:
//    complex_imag(std::complex<T>& c) : c(c) { }
//    operator T() const { return c.imag(); }
//    void operator=(T t) { c = std::complex<T>(c.real(), t); }
//private:
//    std::complex<T>& c;
//};
//
//template<int N>
//struct get_complex_element;
//
//template<>
//struct get_complex_element<0> {
//    template<typename T>
//    static complex_real<T> 
//    execute(std::complex<T>& c) { return complex_real<T>(c); }
//
//    template<typename T>
//    static T execute(const std::complex<T>& c) { return c.real(); }
//};
//
//template<>
//struct get_complex_element<1> {
//    template<typename T>
//    static complex_imag<T> 
//    execute(std::complex<T>& c) { return complex_imag<T>(c); }
//
//    template<typename T>
//    static T execute(const std::complex<T>& c) { return c.imag(); }
//};
//
//} // end namespace detail.
//
//template<typename T>
//struct is_tuple_like_impl< std::complex<T> > : mpl::true_ { };
//
//template<typename T>
//struct tuple_size_impl< std::complex<T> > : mpl::int_<2> { };
//
//template<int N, typename T>
//typename
//mpl::if_c< 
//    N, detail::complex_imag<T>, detail::complex_real<T> 
//>::type 
//tuple_get(std::complex<T>& c)
//{ 
//    BOOST_STATIC_ASSERT(N == 0 || N == 1);
//    return detail::get_complex_element<N>::execute(c);
//}
//
//template<int N, typename T>
//T tuple_get(const std::complex<T>& c)
//{ 
//    BOOST_STATIC_ASSERT(N == 0 || N == 1);
//    return detail::get_complex_element<N>::execute(c);
//}
//
//template<int N, typename T>
//struct tuple_element< N, std::complex<T> > { 
//    BOOST_STATIC_ASSERT(N == 0 || N == 1); 
//    typedef T type;
//};
                    
//------------------Definition of tuple operations for tuples-----------------//

template<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, typename T)>
struct is_tuple_like< tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)> > 
    : mpl::true_ 
    { };

template<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, typename T)>
struct tuple_size< tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)> > 
    : mpl::int_<
          tuples::length< 
              tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)> 
          >::value
      > 
    { };

template<int N, BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, typename T)>
struct tuple_element< N, tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)> > { 
    typedef tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)>
            tuple_type;
    typedef typename boost::tuples::element<N, tuple_type>::type 
            type;
};

template<int N, BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, typename T)>
typename 
add_reference<
    typename 
    tuples::element< 
        N, 
        tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)> 
    >::type
>::type
tuple_get(tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)>& t)
{ return boost::tuples::get<N>(t); }

template<int N, BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, typename T)>
typename 
add_reference<
    typename 
    tuples::element< 
        N, 
        const tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)> 
    >::type
>::type
tuple_get(const tuple<BOOST_PP_ENUM_PARAMS(BOOST_IOSTREAMS_TUPLE_MAX_ARITY, T)>& t)
{ return boost::tuples::get<N>(t); }

//------------------Definition of tuple operations for boost::array---------//

template<typename T, std::size_t N>
struct is_tuple_like< boost::array<T, N> > : mpl::true_ { };

template<typename T, std::size_t N>
struct tuple_size< boost::array<T, N> > : mpl::int_<N> { };

template<int N, typename T, std::size_t M>
T& tuple_get(boost::array<T, M>& ar)
{ 
    BOOST_STATIC_ASSERT(N < M);
    return ar[N]; 
}

template<int N, typename T, std::size_t M>
const T& tuple_get(const boost::array<T, M>& ar)
{ 
    BOOST_STATIC_ASSERT(N < M);
    return ar[N]; 
}

template<int N, typename T, std::size_t M>
struct tuple_element< N, boost::array<T, M> > { 
    BOOST_STATIC_ASSERT(N < M);
    typedef T type;
};

////------------------Definition of tuple operations for boost::rational--------//
//
//namespace detail {
//
//template<typename T>
//class rational_numerator {
//public:
//    rational_numerator(boost::rational<T>& r) : r(r) { }
//    operator T() const { return r.numerator(); }
//    void operator=(T t) { r = boost::rational<T>(t, r.denominator()); }
//private:
//    boost::rational<T>& r;
//};
//
//template<typename T>
//class rational_denominator {
//public:
//    rational_denominator(boost::rational<T>& r) : r(r) { }
//    operator T() const { return r.denominator(); }
//    void operator=(T t) { r = boost::rational<T>(r.numerator(), t); }
//private:
//    boost::rational<T>& r;
//};
//
//template<int N>
//struct get_rational_element;
//
//template<>
//struct get_rational_element<0> {
//    template<typename T>
//    static rational_numerator<T> 
//    execute(boost::rational<T>& r) { return rational_numerator<T>(r); }
//
//    template<typename T>
//    static T execute(const boost::rational<T>& r) { return r.numerator(); }
//};
//
//template<>
//struct get_rational_element<1> {
//    template<typename T>
//    static rational_denominator<T> 
//    execute(boost::rational<T>& r) { return rational_denominator<T>(r); }
//
//    template<typename T>
//    static T execute(const boost::rational<T>& r) { return r.denominator(); }
//};
//
//} // end namespace detail.
//
//template<typename T>
//struct is_tuple_like< boost::rational<T> > : mpl::true_ { };
//
//template<typename T>
//struct tuple_size< boost::rational<T> > : mpl::int_<2> { };
//
//template<int N, typename T>
//typename
//mpl::if_c< 
//    N, detail::rational_denominator<T>, detail::rational_numerator<T> 
//>::type 
//tuple_get(boost::rational<T>& r)
//{ 
//    BOOST_STATIC_ASSERT(N == 0 || N == 1);
//    return detail::get_rational_element<N>::execute(r);
//}
//
//template<int N, typename T>
//T tuple_get(const boost::rational<T>& r)
//{ 
//    BOOST_STATIC_ASSERT(N == 0 || N == 1);
//    return detail::get_rational_element<N>::execute(r);
//}
//
//template<int N, typename T>
//struct tuple_element< N, boost::rational<T> > { 
//    BOOST_STATIC_ASSERT(N == 0 || N == 1); 
//    typedef T type;
//};
                    
} } // End namespaces io, boost.

#endif // #ifndef BOOST_IOSTREAMS_DETAIL_TUPLE_HPP_INCLUDED