_tuple.h

Go to the documentation of this file.

// -*- C++ -*-
 
#ifndef _RWSTD_RW_TUPLE_H_INCLUDED
#  define _RWSTD_RW_TUPLE_H_INCLUDED
 
#  include <rw/_defs.h>
 
#  include <rw/_allocator.h>        // for std::allocator_arg_t
#  include <rw/_forward.h>          // for _RWSTD_FORWARD, _RWSTD_MOVE
#  include <rw/_meta_other.h>       // for _RWSTD_DECAY
 
 
_RWSTD_NAMESPACE (std) {
 
template <class _TypeT>
class reference_wrapper;
 
}   // namespace std
 
 
_RWSTD_NAMESPACE (__rw) {
 
 
// internal tuple class template
 
#  if !defined _RWSTD_NO_VARIADIC_TEMPLATES
 
template <class... _TypesT>
class __rw_tuple;
 
_RWSTD_SPECIALIZED_CLASS
class __rw_tuple<>
{
    // empty
};
 
template <class _HeadT, class... _TailT>
class __rw_tuple<_HeadT, _TailT...>
    : public __rw_tuple<_TailT...>
{
    typedef __rw_tuple<_TailT...>   _Base;
 
    _HeadT  _C_data;
 
public:
 
    __rw_tuple ()
        : _Base (), _C_data () { /* empty */ }
 
    __rw_tuple (const __rw_tuple& __tuple)
        : _Base (__tuple._C_tail ())
        , _C_data (__tuple._C_data) { /* empty */ }
 
    __rw_tuple& operator= (const __rw_tuple& __tuple) {
        _Base::operator= (__tuple._C_tail ());
        _C_data = __tuple._C_data;
        return *this;
    }
 
    explicit
    __rw_tuple (const _HeadT& __head, const _TailT&... __tail)
        : _Base (__tail...), _C_data (__head) { /* empty */ }
 
    template <class _HeadU, class... _TailU>
    __rw_tuple (const __rw_tuple<_HeadU, _TailU...>& __tuple)
        : _Base (__tuple._C_tail ())
        , _C_data (__tuple._C_head ()) { /* empty */ }
 
    template <class _HeadU, class... _TailU>
    __rw_tuple& operator= (const __rw_tuple<_HeadU, _TailU...>& __tuple) {
        _Base::operator= (__tuple._C_tail ());
        _C_data = __tuple._C_head ();
        return *this;
    }
 
#    if !defined _RWSTD_NO_RVALUE_REFERENCES
 
    __rw_tuple (__rw_tuple&& __tuple)
        : _Base (_STD::move<_Base&&> (__tuple._C_tail ()))
        , _C_data (_RWSTD_FORWARD (_HeadT, __tuple._C_data)) { /* empty */ }
 
    __rw_tuple& operator= (__rw_tuple&& __tuple) {
        _Base::operator= (_RWSTD_FORWARD (_Base, __tuple._C_tail ()));
        _C_data = _RWSTD_MOVE (__tuple._C_data);
        return *this;
    }
 
    template <class _HeadU, class... _TailU>
    explicit __rw_tuple (_HeadU&& __head, _TailU&&... __tail)
        : _Base (_RWSTD_FORWARD (_TailU, __tail)...)
        , _C_data (_RWSTD_MOVE (__head)) { /* empty */ }
 
    template <class _HeadU, class... _TailU>
    __rw_tuple (__rw_tuple<_HeadU, _TailU...>&& __tuple)
        : _Base (_RWSTD_MOVE (__tuple._C_tail ()))
        , _C_data (_RWSTD_MOVE (__tuple._C_head ())) { /* empty */ }
 
    template <class _HeadU, class... _TailU>
    __rw_tuple& operator= (__rw_tuple<_HeadU, _TailU...>&& __tuple) {
        _Base::operator= (_RWSTD_MOVE (__tuple._C_tail ()));
        _C_data = _RWSTD_MOVE (__tuple._C_head ());
        return *this;
    }
 
    // allocator-extended constructors:
 
    template <class _Alloc, class... _TypesU>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc,
                const _TypesU&&... __values);
 
    template <class _Alloc>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc,
                __rw_tuple&& __tuple);
 
    template <class _Alloc, class... _TypesU>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc,
                __rw_tuple<_TypesU...>&& __tuple);
 
#    endif   // !defined _RWSTD_NO_RVALUE_REFERENCES
 
    template <class _Alloc>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc);
 
    template <class _Alloc>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc,
           const _HeadT& __head, const _TailT&... __tail);
 
    template <class _Alloc>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc,
                const __rw_tuple& __tuple);
 
    template <class _Alloc, class... _TypesU>
    __rw_tuple (_STD::allocator_arg_t, const _Alloc& __alloc,
                const __rw_tuple<_TypesU...>& __tuple);
 
    // accessors:
 
    _HeadT&         _C_head ()       { return _C_data; }
    const _HeadT&   _C_head () const { return _C_data; }
 
    _Base&          _C_tail ()       { return *this; }
    const _Base&    _C_tail () const { return *this; }
 
};
 
 
struct __rw_ignore
{
    template <class _TypeT>
    void operator= (const _TypeT&) const {}
};
 
 
template <class _TypeT>
struct __rw_deduce_ref
{
    typedef _TypeT  _C_type;
};
 
template <class _TypeT>
struct __rw_deduce_ref<_STD::reference_wrapper<_TypeT> >
{
    typedef _TypeT& _C_type;
};
 
template <class _TypeT>
struct __rw_deduce_ref<const _STD::reference_wrapper<_TypeT> >
{
    typedef _TypeT& _C_type;
};
 
template <class _TypeT>
struct __rw_make_tuple
{
    typedef typename _RWSTD_DECAY (_TypeT)                 _C_decay;
    typedef typename __rw_deduce_ref<_C_decay>::_C_type    _C_type;
};
 
 
template <class...  _TypesT, class... _TypesU>
bool operator== (const __rw_tuple<_TypesT...>& __x,
                 const __rw_tuple<_TypesU...>& __y) {
    return     (__x._C_head () == __y._C_head ())
            && (__x._C_tail () == __y._C_tail ());
}
 
_RWSTD_SPECIALIZED_FUNCTION
bool operator== (const __rw_tuple<>& /*__x*/,
                 const __rw_tuple<>& /*__y*/) {
    return true;
}
 
template <class...  _TypesT, class... _TypesU>
bool operator< (const __rw_tuple<_TypesT...>& __x,
                const __rw_tuple<_TypesU...>& __y) {
    return     (__x._C_head () < __y._C_head ())
            || (  !(__y._C_head () < __x._C_head ())
                && (__x._C_tail () < __y._C_tail ()));
}
 
_RWSTD_SPECIALIZED_FUNCTION
bool operator< (const __rw_tuple<>& /*__x*/,
                const __rw_tuple<>& /*__y*/) {
    return false;
}
 
#  endif   // !defined _RWSTD_NO_VARIADIC_TEMPLATES
 
 
}   // namespace __rw
 
 
#endif   // _RWSTD_TUPLE_INCLUDED