354 lines
10 KiB
C++
354 lines
10 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// (C) Copyright Ion Gaztanaga 2005-2012.
|
|
//
|
|
// 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)
|
|
//
|
|
// See http://www.boost.org/libs/container for documentation.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_PAIR_HPP
|
|
#define BOOST_CONTAINER_CONTAINER_DETAIL_PAIR_HPP
|
|
|
|
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
|
|
# pragma once
|
|
#endif
|
|
|
|
#include "config_begin.hpp"
|
|
#include <boost/container/detail/workaround.hpp>
|
|
|
|
#include <boost/container/detail/mpl.hpp>
|
|
#include <boost/container/detail/type_traits.hpp>
|
|
#include <boost/container/detail/mpl.hpp>
|
|
#include <boost/container/detail/type_traits.hpp>
|
|
|
|
#include <utility> //std::pair
|
|
|
|
#include <boost/move/move.hpp>
|
|
#include <boost/type_traits/is_class.hpp>
|
|
|
|
#ifndef BOOST_CONTAINER_PERFECT_FORWARDING
|
|
#include <boost/container/detail/preprocessor.hpp>
|
|
#endif
|
|
|
|
namespace boost {
|
|
namespace container {
|
|
namespace container_detail {
|
|
|
|
template <class T1, class T2>
|
|
struct pair;
|
|
|
|
template <class T>
|
|
struct is_pair
|
|
{
|
|
static const bool value = false;
|
|
};
|
|
|
|
template <class T1, class T2>
|
|
struct is_pair< pair<T1, T2> >
|
|
{
|
|
static const bool value = true;
|
|
};
|
|
|
|
template <class T1, class T2>
|
|
struct is_pair< std::pair<T1, T2> >
|
|
{
|
|
static const bool value = true;
|
|
};
|
|
|
|
struct pair_nat;
|
|
|
|
struct piecewise_construct_t { };
|
|
static const piecewise_construct_t piecewise_construct = piecewise_construct_t();
|
|
|
|
/*
|
|
template <class T1, class T2>
|
|
struct pair
|
|
{
|
|
template <class U, class V> pair(pair<U, V>&& p);
|
|
template <class... Args1, class... Args2>
|
|
pair(piecewise_construct_t, tuple<Args1...> first_args,
|
|
tuple<Args2...> second_args);
|
|
|
|
template <class U, class V> pair& operator=(const pair<U, V>& p);
|
|
pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
|
|
is_nothrow_move_assignable<T2>::value);
|
|
template <class U, class V> pair& operator=(pair<U, V>&& p);
|
|
|
|
void swap(pair& p) noexcept(noexcept(swap(first, p.first)) &&
|
|
noexcept(swap(second, p.second)));
|
|
};
|
|
|
|
template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
|
|
template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
|
|
template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
|
|
template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
|
|
template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
|
|
template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
|
|
*/
|
|
|
|
|
|
template <class T1, class T2>
|
|
struct pair
|
|
{
|
|
private:
|
|
BOOST_COPYABLE_AND_MOVABLE(pair)
|
|
|
|
public:
|
|
typedef T1 first_type;
|
|
typedef T2 second_type;
|
|
|
|
T1 first;
|
|
T2 second;
|
|
|
|
//Default constructor
|
|
pair()
|
|
: first(), second()
|
|
{}
|
|
|
|
//pair copy assignment
|
|
pair(const pair& x)
|
|
: first(x.first), second(x.second)
|
|
{}
|
|
|
|
//pair move constructor
|
|
pair(BOOST_RV_REF(pair) p)
|
|
: first(::boost::move(p.first)), second(::boost::move(p.second))
|
|
{}
|
|
|
|
template <class D, class S>
|
|
pair(const pair<D, S> &p)
|
|
: first(p.first), second(p.second)
|
|
{}
|
|
|
|
template <class D, class S>
|
|
pair(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
|
|
: first(::boost::move(p.first)), second(::boost::move(p.second))
|
|
{}
|
|
|
|
//pair from two values
|
|
pair(const T1 &t1, const T2 &t2)
|
|
: first(t1)
|
|
, second(t2)
|
|
{}
|
|
|
|
template<class U, class V>
|
|
pair(BOOST_FWD_REF(U) u, BOOST_FWD_REF(V) v)
|
|
: first(::boost::forward<U>(u))
|
|
, second(::boost::forward<V>(v))
|
|
{}
|
|
|
|
//And now compatibility with std::pair
|
|
pair(const std::pair<T1, T2>& x)
|
|
: first(x.first), second(x.second)
|
|
{}
|
|
|
|
template <class D, class S>
|
|
pair(const std::pair<D, S>& p)
|
|
: first(p.first), second(p.second)
|
|
{}
|
|
|
|
pair(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
|
|
: first(::boost::move(p.first)), second(::boost::move(p.second))
|
|
{}
|
|
|
|
template <class D, class S>
|
|
pair(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
|
|
: first(::boost::move(p.first)), second(::boost::move(p.second))
|
|
{}
|
|
|
|
//piecewise_construct missing
|
|
//template <class U, class V> pair(pair<U, V>&& p);
|
|
//template <class... Args1, class... Args2>
|
|
// pair(piecewise_construct_t, tuple<Args1...> first_args,
|
|
// tuple<Args2...> second_args);
|
|
/*
|
|
//Variadic versions
|
|
template<class U>
|
|
pair(BOOST_CONTAINER_PP_PARAM(U, u), typename container_detail::disable_if
|
|
< container_detail::is_pair< typename container_detail::remove_ref_const<U>::type >, pair_nat>::type* = 0)
|
|
: first(::boost::forward<U>(u))
|
|
, second()
|
|
{}
|
|
|
|
#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
|
|
|
|
template<class U, class V, class ...Args>
|
|
pair(U &&u, V &&v)
|
|
: first(::boost::forward<U>(u))
|
|
, second(::boost::forward<V>(v), ::boost::forward<Args>(args)...)
|
|
{}
|
|
|
|
#else
|
|
|
|
#define BOOST_PP_LOCAL_MACRO(n) \
|
|
template<class U, BOOST_PP_ENUM_PARAMS(n, class P)> \
|
|
pair(BOOST_CONTAINER_PP_PARAM(U, u) \
|
|
,BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
|
|
: first(::boost::forward<U>(u)) \
|
|
, second(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)) \
|
|
{} \
|
|
//!
|
|
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
|
|
#include BOOST_PP_LOCAL_ITERATE()
|
|
#endif
|
|
*/
|
|
//pair copy assignment
|
|
pair& operator=(BOOST_COPY_ASSIGN_REF(pair) p)
|
|
{
|
|
first = p.first;
|
|
second = p.second;
|
|
return *this;
|
|
}
|
|
|
|
//pair move assignment
|
|
pair& operator=(BOOST_RV_REF(pair) p)
|
|
{
|
|
first = ::boost::move(p.first);
|
|
second = ::boost::move(p.second);
|
|
return *this;
|
|
}
|
|
|
|
template <class D, class S>
|
|
typename ::boost::container::container_detail::enable_if_c
|
|
< !(::boost::container::container_detail::is_same<T1, D>::value &&
|
|
::boost::container::container_detail::is_same<T2, S>::value)
|
|
, pair &>::type
|
|
operator=(const pair<D, S>&p)
|
|
{
|
|
first = p.first;
|
|
second = p.second;
|
|
return *this;
|
|
}
|
|
|
|
template <class D, class S>
|
|
typename ::boost::container::container_detail::enable_if_c
|
|
< !(::boost::container::container_detail::is_same<T1, D>::value &&
|
|
::boost::container::container_detail::is_same<T2, S>::value)
|
|
, pair &>::type
|
|
operator=(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
|
|
{
|
|
first = ::boost::move(p.first);
|
|
second = ::boost::move(p.second);
|
|
return *this;
|
|
}
|
|
|
|
//std::pair copy assignment
|
|
pair& operator=(const std::pair<T1, T2> &p)
|
|
{
|
|
first = p.first;
|
|
second = p.second;
|
|
return *this;
|
|
}
|
|
|
|
template <class D, class S>
|
|
pair& operator=(const std::pair<D, S> &p)
|
|
{
|
|
first = ::boost::move(p.first);
|
|
second = ::boost::move(p.second);
|
|
return *this;
|
|
}
|
|
|
|
//std::pair move assignment
|
|
pair& operator=(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
|
|
{
|
|
first = ::boost::move(p.first);
|
|
second = ::boost::move(p.second);
|
|
return *this;
|
|
}
|
|
|
|
template <class D, class S>
|
|
pair& operator=(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
|
|
{
|
|
first = ::boost::move(p.first);
|
|
second = ::boost::move(p.second);
|
|
return *this;
|
|
}
|
|
|
|
//swap
|
|
void swap(pair& p)
|
|
{
|
|
using std::swap;
|
|
swap(this->first, p.first);
|
|
swap(this->second, p.second);
|
|
}
|
|
};
|
|
|
|
template <class T1, class T2>
|
|
inline bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y)
|
|
{ return static_cast<bool>(x.first == y.first && x.second == y.second); }
|
|
|
|
template <class T1, class T2>
|
|
inline bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y)
|
|
{ return static_cast<bool>(x.first < y.first ||
|
|
(!(y.first < x.first) && x.second < y.second)); }
|
|
|
|
template <class T1, class T2>
|
|
inline bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y)
|
|
{ return static_cast<bool>(!(x == y)); }
|
|
|
|
template <class T1, class T2>
|
|
inline bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y)
|
|
{ return y < x; }
|
|
|
|
template <class T1, class T2>
|
|
inline bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y)
|
|
{ return static_cast<bool>(!(x < y)); }
|
|
|
|
template <class T1, class T2>
|
|
inline bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y)
|
|
{ return static_cast<bool>(!(y < x)); }
|
|
|
|
template <class T1, class T2>
|
|
inline pair<T1, T2> make_pair(T1 x, T2 y)
|
|
{ return pair<T1, T2>(x, y); }
|
|
|
|
template <class T1, class T2>
|
|
inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
|
|
{
|
|
swap(x.first, y.first);
|
|
swap(x.second, y.second);
|
|
}
|
|
|
|
} //namespace container_detail {
|
|
} //namespace container {
|
|
|
|
|
|
//Without this specialization recursive flat_(multi)map instantiation fails
|
|
//because is_enum needs to instantiate the recursive pair, leading to a compilation error).
|
|
//This breaks the cycle clearly stating that pair is not an enum avoiding any instantiation.
|
|
template<class T>
|
|
struct is_enum;
|
|
|
|
template<class T, class U>
|
|
struct is_enum< ::boost::container::container_detail::pair<T, U> >
|
|
{
|
|
static const bool value = false;
|
|
};
|
|
|
|
//This specialization is needed to avoid instantiation of pair in
|
|
//is_class, and allow recursive maps.
|
|
template <class T1, class T2>
|
|
struct is_class< ::boost::container::container_detail::pair<T1, T2> >
|
|
: public ::boost::true_type
|
|
{};
|
|
|
|
#ifdef BOOST_NO_RVALUE_REFERENCES
|
|
|
|
template<class T1, class T2>
|
|
struct has_move_emulation_enabled< ::boost::container::container_detail::pair<T1, T2> >
|
|
: ::boost::true_type
|
|
{};
|
|
|
|
#endif
|
|
|
|
|
|
} //namespace boost {
|
|
|
|
#include <boost/container/detail/config_end.hpp>
|
|
|
|
#endif //#ifndef BOOST_CONTAINER_DETAIL_PAIR_HPP
|