// -*- C++ -*-
/***************************************************************************
 *
 * tuple - fixed-size collections with variable, heterogenous types
 *
 * $Id: tuple 677458 2008-07-16 22:49:27Z elemings $
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 2008 Rogue Wave Software, Inc.
 *
 **************************************************************************/

#ifndef _RWSTD_TUPLE_INCLUDED
#  define _RWSTD_TUPLE_INCLUDED

#  include <rw/_defs.h>

#  if defined _RWSTD_NO_EXT_CXX_0X
#    error _RWSTD_NO_EXT_CXX_0X defined and C++0x header included
#  endif   // defined _RWSTD_NO_EXT_CXX_0X

#  include <rw/_forward.h>          // for _RWSTD_FORWARD, _RWSTD_MOVE
#  include <rw/_meta_cv.h>          // for _RWSTD_ADD_CONST
#  include <rw/_meta_help.h>        // for __rw_integral_constant
#  include <rw/_meta_ref.h>         // for _RWSTD_ADD_LVALUE_REFERENCE
#  include <rw/_pair.h>             // for std::pair

#  include <rw/_tuple.h>

#  if !defined _RWSTD_NO_VARIADIC_TEMPLATES


_RWSTD_NAMESPACE (std) {


// 20.3.1, class template tuple:

template <class... _TypesT>
class tuple;

_RWSTD_SPECIALIZED_CLASS
class tuple<>
{
    // empty
};

template <class... _TypesT>
class tuple
    : public _RW::__rw_tuple<_TypesT...>
{
    typedef _RW::__rw_tuple<_TypesT...> _Base;

#    undef _BaseU
#    define _BaseU  _RW::__rw_tuple<_TypesU...>

public:

    tuple ()
        : _Base () { /* empty */ }

    // employ _RWSTD_STATIC_CAST to ensure compiler binds to correct
    // base class ctors and operators

    tuple (const tuple& __tuple)
        : _Base (_RWSTD_STATIC_CAST (const _Base&, __tuple)) { /* empty */ }

    tuple& operator= (const tuple& __tuple) {
        _Base::operator= (_RWSTD_STATIC_CAST (const _Base&, __tuple));
        return *this;
    }

    explicit
    tuple (const _TypesT&... __values)
        : _Base (__values...) { /* empty */ }

    template <class... _TypesU>
    tuple (const tuple<_TypesU...>& __tuple)
        : _Base (_RWSTD_STATIC_CAST (const _BaseU&, __tuple)) { /* empty */ }

    template <class... _TypesU>
    tuple& operator= (const tuple<_TypesU...>& __tuple) {
        _Base::operator= (_RWSTD_STATIC_CAST (const _BaseU&, __tuple));
        return *this;
    }

#    if !defined _RWSTD_NO_RVALUE_REFERENCES

    tuple (tuple&& __tuple)
        : _Base (_RWSTD_FORWARD (_Base, __tuple)) { /* empty */ }

    tuple& operator= (tuple&& __tuple) {
        _Base::operator= (_RWSTD_FORWARD (_Base, __tuple));
        return *this;
    }

    template <class... _TypesU>
    explicit tuple (_TypesU&&... __values)
        : _Base (_RWSTD_FORWARD (_TypesU, __values)...) { /* empty */ }

    template <class... _TypesU>
    tuple (tuple<_TypesU...>&& __tuple)
        : _Base (_RWSTD_FORWARD (_BaseU, __tuple)) { /* empty */ }

    template <class... _TypesU>
    tuple& operator= (tuple<_TypesU...>&& __tuple) {
        _Base::operator= (_RWSTD_FORWARD (_BaseU, __tuple));
        return *this;
    }

    // allocator-extended constructors:

    template <class _Alloc, class... _TypesU>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           const _TypesU&&... __values);

    template <class _Alloc>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           tuple&& __tuple);

    template <class _Alloc, class... _TypesU>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           tuple<_TypesU...>&& __tuple);

#    endif   // !defined _RWSTD_NO_RVALUE_REFERENCES

#    undef _BaseU

    template <class _Alloc>
    tuple (allocator_arg_t, const _Alloc& __alloc);

    template <class _Alloc>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           const _TypesT&... __values);

    template <class _Alloc>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           const tuple& __tuple);

    template <class _Alloc, class... _TypesU>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           const tuple<_TypesU...>& __tuple);

};


template <class _TypeT1, class _TypeT2>
class tuple<_TypeT1, _TypeT2>
    : public _RW::__rw_tuple<_TypeT1, _TypeT2>
{
    typedef _RW::__rw_tuple<_TypeT1, _TypeT2>   _Base;

#    undef _BaseU
#    define _BaseU  _RW::__rw_tuple<_TypeU1, _TypeU2>

public:

    // 20.3.1.2, construction:

    tuple ()
        : _Base () { /* empty */ }

    tuple (const tuple& __tuple)
        : _Base (_RWSTD_STATIC_CAST (const _Base&, __tuple)) { /* empty */ }

    tuple& operator= (const tuple& __tuple) {
        _Base::operator= (_RWSTD_STATIC_CAST (const _Base&, __tuple));
        return *this;
    }

    tuple (const _TypeT1& __x, const _TypeT2& __y)
        : _Base (__x, __y) { /* empty */ }

    template <class _TypeU1, class _TypeU2>
    tuple (const tuple<_TypeU1, _TypeU2>& __tuple)
        : _Base (_RWSTD_STATIC_CAST (const _BaseU&, __tuple)) { /* empty */ }

    template <class _TypeU1, class _TypeU2>
    tuple& operator= (const tuple<_TypeU1, _TypeU2>& __tuple) {
        _Base::operator= (_RWSTD_STATIC_CAST (const _BaseU&, __tuple));
        return *this;
    }

    template <class _TypeU1, class _TypeU2>
    tuple (const pair<_TypeU1, _TypeU2>& __pair)
        : _Base (__pair.first, __pair.second) { /* empty */ }

    template <class _TypeU1, class _TypeU2>
    tuple& operator= (const pair<_TypeU1, _TypeU2>& __pair) {
        _Base::operator= (__pair.first, __pair.second);
        return *this;
    }

#    if !defined _RWSTD_NO_RVALUE_REFERENCES

    template <class _TypeU1, class _TypeU2>
    tuple (_TypeU1&& __x, _TypeU2&& __y)
        : _Base (_RWSTD_MOVE (__x), _RWSTD_MOVE (__y)) { /* empty */ }

    tuple (tuple&& __tuple)
        : _Base (_RWSTD_FORWARD (_Base, __tuple)) { /* empty */ }

    tuple& operator= (tuple&& __tuple) {
        _Base::operator= (_RWSTD_FORWARD (_Base, __tuple));
        return *this;
    }

    template <class _TypeU1, class _TypeU2>
    tuple (tuple<_TypeU1, _TypeU2>&& __tuple)
        : _Base (_RWSTD_FORWARD (_BaseU, __tuple))
    { /* empty */ }

    template <class _TypeU1, class _TypeU2>
    tuple& operator= (tuple<_TypeU1, _TypeU2>&& __tuple) {
        _Base::operator= (_RWSTD_FORWARD (_BaseU, __tuple));
        return *this;
    }

    template <class _TypeU1, class _TypeU2>
    tuple (pair<_TypeU1, _TypeU2>&& __pair)
        : _Base (_RWSTD_MOVE (__pair.first),
                 _RWSTD_MOVE ( __pair.second)) { /* empty */ }

    template <class _TypeU1, class _TypeU2>
    tuple& operator= (pair<_TypeU1, _TypeU2>&& __pair) {
        _Base::operator= (__pair.first, __pair.second);
        return *this;
    }

    // allocator-extended constructors:

    template <class _Alloc, class _TypeU1, class _TypeU2>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           pair<_TypeU1, _TypeU2>&& __pair);

#    endif   // !defined _RWSTD_NO_RVALUE_REFERENCES

#    undef _BaseU

    template <class _Alloc, class _TypeU1, class _TypeU2>
    tuple (allocator_arg_t, const _Alloc& __alloc,
           const pair<_TypeU1, _TypeU2>& __pair);

};


// 20.3.1.1, tuple traits:

template <class _Type, class _Alloc>
struct uses_allocator;

template <class... _TypesT, class _Alloc>
struct uses_allocator<tuple<_TypesT...>, _Alloc>
    : _RW::__rw_true_type
{
    // empty
};


template <class _Type>
struct constructible_with_allocator_prefix;

template <class... _TypesT>
struct constructible_with_allocator_prefix<tuple<_TypesT...> >
    : _RW::__rw_true_type
{
    // empty
};


// 20.3.3, tuple creation functions:

const _RW::__rw_ignore ignore = _RW::__rw_ignore ();


#    if !defined _RWSTD_NO_RVALUE_REFERENCES

template <class... _TypesT>
inline tuple<typename _RW::__rw_make_tuple<_TypesT>::_C_type...>
make_tuple (_TypesT&&... __values)
{
    typedef tuple<typename _RW::__rw_make_tuple<_TypesT>::_C_type...> _Tuple;
    return _Tuple (_RWSTD_FORWARD (_TypesT, __values)...);
}


template <class... _TypesT, class... _TypesU>
tuple<_TypesT..., _TypesU...>
tuple_cat (tuple<_TypesT...>&& __x,
           const tuple<_TypesU...>& __y);

template <class... _TypesT, class... _TypesU>
tuple<_TypesT..., _TypesU...>
tuple_cat (const tuple<_TypesT...>& __x,
           tuple<_TypesU...>&& __y);

template <class... _TypesT, class... _TypesU>
tuple<_TypesT..., _TypesU...>
tuple_cat (tuple<_TypesT...>&& __x,
           tuple<_TypesU...>&& __y);

#    endif   // !defined _RWSTD_NO_RVALUE_REFERENCES

template <class... _TypesT, class... _TypesU>
tuple<_TypesT..., _TypesU...>
tuple_cat (const tuple<_TypesT...>& __x,
           const tuple<_TypesU...>& __y);


template <class... _TypesT>
inline tuple<_TypesT&...>
tie (_TypesT&... __values)
{
    return tuple<_TypesT&...> (__values...);
}


// 20.3.1.4, tuple helper classes:

template <class _TypesT>
class tuple_size;

template <class... _TypesT>
class tuple_size< tuple<_TypesT...> >
    : public _RW::__rw_integral_constant< _RWSTD_SIZE_T,
                                          sizeof... (_TypesT) >
{
    // empty
};


template <_RWSTD_SIZE_T _Index, class... _TypesT>
struct tuple_element;

template <class _Head, class... _Tail>
struct tuple_element<0, tuple<_Head, _Tail...> >
{
    typedef _Head type;

//internal:

    typedef _RW::__rw_tuple<_Head, _Tail...>    _Tuple;

    typedef typename _RWSTD_ADD_LVALUE_REFERENCE (_Head)       _Ref;
    typedef typename _RWSTD_ADD_CONST (_Head)                  _ConstHead;
    typedef typename _RWSTD_ADD_LVALUE_REFERENCE (_ConstHead)  _ConstRef;

    static _Ref
    _C_get (_Tuple& __tuple) { return __tuple._C_head (); }

    static _ConstRef
    _C_get (const _Tuple& __tuple) { return __tuple._C_head (); }
};

template <_RWSTD_SIZE_T _Index, class _Head, class... _Tail>
struct tuple_element<_Index, tuple<_Head, _Tail...> >
    : public tuple_element<_Index - 1, tuple<_Tail...> >
{
    // empty
};


// 20.3.1.5, element access:

template <_RWSTD_SIZE_T _Index, class _Head, class... _Tail>
inline typename tuple_element<_Index, tuple<_Head, _Tail...> >::_Ref
get (tuple<_Head, _Tail...>& __tuple)
{
    typedef tuple_element<_Index, tuple<_Head, _Tail...> > _Tuple;
    return _Tuple::_C_get (__tuple);
}

template <_RWSTD_SIZE_T _Index, class _Head, class... _Tail>
inline typename tuple_element<_Index, tuple<_Head, _Tail...> >::_ConstRef
get (const tuple<_Head, _Tail...>& __tuple)
{
    typedef tuple_element<_Index, tuple<_Head, _Tail...> > _Tuple;
    return _Tuple::_C_get (__tuple);
}


// 20.3.1.6, relational operators:

template <class... _TypesT, class... _TypesU>
inline bool
operator== (const tuple<_TypesT...>& __x,
            const tuple<_TypesU...>& __y)
{
    return _RWSTD_STATIC_CAST (const _RW::__rw_tuple<_TypesT...>&, __x)
           == _RWSTD_STATIC_CAST (const _RW::__rw_tuple<_TypesU...>&, __y);
}

_RWSTD_SPECIALIZED_FUNCTION
inline bool
operator== (const tuple<>& /*__x*/,
            const tuple<>& /*__y*/)
{
    return true;
}

template <class... _TypesT, class... _TypesU>
inline bool
operator< (const tuple<_TypesT...>& __x,
           const tuple<_TypesU...>& __y)
{
    return _RWSTD_STATIC_CAST (const _RW::__rw_tuple<_TypesT...>&, __x)
           < _RWSTD_STATIC_CAST (const _RW::__rw_tuple<_TypesU...>&, __y);
}

_RWSTD_SPECIALIZED_FUNCTION
inline bool
operator< (const tuple<>& /*__x*/,
           const tuple<>& /*__y*/)
{
    return false;
}

template <class... _TypesT, class... _TypesU>
inline bool
operator!= (const tuple<_TypesT...>& __x,
            const tuple<_TypesU...>& __y)
{
    return !(__x == __y);
}

template <class... _TypesT, class... _TypesU>
inline bool
operator> (const tuple<_TypesT...>& __x,
           const tuple<_TypesU...>& __y)
{
    return __y < __x;
}

template <class... _TypesT, class... _TypesU>
inline bool
operator<= (const tuple<_TypesT...>& __x,
            const tuple<_TypesU...>& __y)
{
    return !(__y < __x);
}

template <class... _TypesT, class... _TypesU>
inline bool
operator>= (const tuple<_TypesT...>& __x,
            const tuple<_TypesU...>& __y)
{
    return !(__x < __y);
}


}   // namespace std


#  endif   // !defined _RWSTD_NO_VARIADIC_TEMPLATES

#endif   // _RWSTD_TUPLE_INCLUDED