846 lines
31 KiB
C++
846 lines
31 KiB
C++
/**
|
|
* @file include/ActivMiddleware/Misc/ContainerTraits.h
|
|
*
|
|
* @brief Header for container traits.
|
|
*/
|
|
|
|
#if (!defined ACTIV_MISC_CONTAINER_TRAITS_H)
|
|
#define ACTIV_MISC_CONTAINER_TRAITS_H
|
|
|
|
#include "ActivMiddleware/CxxYZ/type_traits.h"
|
|
|
|
#include ACTIV_BOOST_INCLUDE(mpl/and.hpp)
|
|
#include ACTIV_BOOST_INCLUDE(tti/has_member_function.hpp)
|
|
#include ACTIV_BOOST_INCLUDE(tti/has_type.hpp)
|
|
|
|
#include ACTIV_BOOST_INCLUDE(container/container_fwd.hpp)
|
|
#include ACTIV_BOOST_INCLUDE(unordered/unordered_set_fwd.hpp)
|
|
#include ACTIV_BOOST_INCLUDE(unordered/unordered_map_fwd.hpp)
|
|
|
|
#include ACTIV_BOOST_INCLUDE(multi_index_container.hpp)
|
|
#include ACTIV_BOOST_INCLUDE(multi_index/ordered_index_fwd.hpp)
|
|
|
|
#include <deque>
|
|
#include <list>
|
|
#include <map>
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
#if (!defined ACTIV_BOOST_NO_CXX11_HDR_UNORDERED_SET)
|
|
#include <unordered_set>
|
|
#endif
|
|
|
|
#if (!defined ACTIV_BOOST_NO_CXX11_HDR_UNORDERED_MAP)
|
|
#include <unordered_map>
|
|
#endif
|
|
|
|
#include <iterator>
|
|
|
|
// TODO more multi-index index types.
|
|
|
|
//! Activ namespace.
|
|
namespace Activ
|
|
{
|
|
|
|
//! ContainerTraits namespace.
|
|
namespace ContainerTraits
|
|
{
|
|
|
|
namespace Detail
|
|
{
|
|
|
|
// Boost container now defaults to void for ALLOCATOR, so we can't rebind it. Just pass on void in that case.
|
|
template<typename ALLOCATOR, typename TRANSFORMED_TYPE>
|
|
class RebindAllocator
|
|
{
|
|
public:
|
|
#if (ACTIV_CPLUSPLUS >= ACTIV_CPLUSPLUS_11)
|
|
using type = typename std::allocator_traits<ALLOCATOR>::template rebind_alloc<TRANSFORMED_TYPE>;
|
|
#else
|
|
typedef typename ALLOCATOR::template rebind<TRANSFORMED_TYPE>::other type;
|
|
#endif
|
|
};
|
|
|
|
template<typename TRANSFORMED_TYPE>
|
|
class RebindAllocator<void, TRANSFORMED_TYPE>
|
|
{
|
|
public:
|
|
typedef void type;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// "Concept" for all specializations.
|
|
template<typename T>
|
|
class ContainerTraitsImpl
|
|
{
|
|
public:
|
|
typedef CxxYZ::false_type IsSupportedContainer;
|
|
typedef CxxYZ::false_type IsSequence;
|
|
typedef CxxYZ::false_type IsAssociative;
|
|
typedef CxxYZ::false_type IsMapLike;
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef CxxYZ::false_type HasRandomAccess;
|
|
typedef CxxYZ::false_type HasReserve;
|
|
typedef CxxYZ::false_type HasEmplace;
|
|
|
|
// typedef something EmplaceResultType;
|
|
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
ACTIV_BOOST_TTI_HAS_TYPE(key_type)
|
|
ACTIV_BOOST_TTI_HAS_TYPE(mapped_type)
|
|
|
|
template<typename T>
|
|
class IsMapLikeImpl : public Boost::mpl::and_<has_type_key_type<T>, has_type_mapped_type<T> > { };
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template<typename T>
|
|
class IsRandomAccessIterator : public
|
|
CxxYZ::is_base_of<std::random_access_iterator_tag, typename std::iterator_traits<T>::iterator_category> { };
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
#if (defined ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES) || \
|
|
((defined ACTIV_BOOST_DINKUMWARE_STDLIB) && (ACTIV_BOOST_DINKUMWARE_STDLIB <= 520))
|
|
typedef CxxYZ::false_type StdContainerHasEmplace;
|
|
#else
|
|
typedef CxxYZ::true_type StdContainerHasEmplace;
|
|
#endif
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
ACTIV_BOOST_TTI_HAS_MEMBER_FUNCTION(pop_back)
|
|
ACTIV_BOOST_TTI_HAS_MEMBER_FUNCTION(reserve)
|
|
|
|
// Common traits by introspection. Note use of MakeIntegralConstant to ensure we get CxxYZ::true_type or false_type.
|
|
template<typename T>
|
|
class ContainerTraitsImplBase
|
|
{
|
|
public:
|
|
typedef T ContainerType;
|
|
|
|
typedef CxxYZ::true_type IsSupportedContainer;
|
|
typedef typename MakeIntegralConstant<typename has_member_function_pop_back<void (T::*)()>::type>::type IsSequence;
|
|
typedef typename MakeIntegralConstant<typename has_type_key_type<T>::type>::type IsAssociative;
|
|
typedef typename MakeIntegralConstant<IsMapLikeImpl<T> >::type IsMapLike;
|
|
typedef typename MakeIntegralConstant<IsRandomAccessIterator<typename T::iterator> >::type HasRandomAccess;
|
|
typedef typename MakeIntegralConstant<typename has_member_function_reserve<void (T::*)(typename T::size_type)>::type>::type
|
|
HasReserve;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::deque traits.
|
|
template<typename T, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::deque<T, ALLOCATOR> > : public ContainerTraitsImplBase<std::deque<T, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::deque<T, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::deque<TransformedType, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::list traits.
|
|
template<typename T, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::list<T, ALLOCATOR> > : public ContainerTraitsImplBase<std::list<T, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::list<T, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::list<TransformedType, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::vector traits.
|
|
template<typename T, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::vector<T, ALLOCATOR> > : public ContainerTraitsImplBase<std::vector<T, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::vector<T, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::vector<TransformedType, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::container::vector traits.
|
|
template<typename T, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::container::vector<T, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::container::vector<T, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::container::vector<T, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef Boost::container::vector<TransformedType, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::set traits.
|
|
template<typename T, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::set<T, COMPARE, ALLOCATOR> > : public ContainerTraitsImplBase<std::set<T, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::set<T, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::set<TransformedType, COMPARE, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::multiset traits.
|
|
template<typename T, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::multiset<T, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::multiset<T, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::multiset<T, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::multiset<TransformedType, COMPARE, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::container::set traits.
|
|
template<typename T, typename COMPARE, typename ALLOCATOR, typename OPTIONS>
|
|
class ContainerTraitsImpl<Boost::container::set<T, COMPARE, ALLOCATOR, OPTIONS> > :
|
|
public ContainerTraitsImplBase<Boost::container::set<T, COMPARE, ALLOCATOR, OPTIONS> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::container::set<T, COMPARE, ALLOCATOR, OPTIONS> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef Boost::container::set<TransformedType, COMPARE, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::container::multiset traits.
|
|
template<typename T, typename COMPARE, typename ALLOCATOR, typename OPTIONS>
|
|
class ContainerTraitsImpl<Boost::container::multiset<T, COMPARE, ALLOCATOR, OPTIONS> > :
|
|
public ContainerTraitsImplBase<Boost::container::multiset<T, COMPARE, ALLOCATOR, OPTIONS> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::container::multiset<T, COMPARE, ALLOCATOR, OPTIONS> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef Boost::container::multiset<TransformedType, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
#if (!defined ACTIV_BOOST_NO_CXX11_HDR_UNORDERED_SET)
|
|
|
|
// std::unordered_set traits.
|
|
template<typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::unordered_set<T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::unordered_set<T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::unordered_set<T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::unordered_set<TransformedType, HASH, COMPARE, typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::unordered_multiset traits.
|
|
template<typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::unordered_multiset<T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::unordered_multiset<T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::unordered_multiset<T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef std::unordered_multiset<TransformedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
#endif // (!defined ACTIV_BOOST_NO_CXX11_HDR_UNORDERED_SET)
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::unordered_set traits.
|
|
template<typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::unordered_set<T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::unordered_set<T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::unordered_set<T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef Boost::unordered_set<TransformedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::unordered_multiset traits.
|
|
template<typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::unordered_multiset<T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::unordered_multiset<T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::unordered_multiset<T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef Boost::unordered_multiset<TransformedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::map traits.
|
|
template<typename KEY, typename T, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::map<KEY, T, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::map<KEY, T, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::map<KEY, T, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef std::map<TransformedKeyType, TransformedMappedType, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::multimap traits.
|
|
template<typename KEY, typename T, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::multimap<KEY, T, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::multimap<KEY, T, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::multimap<KEY, T, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef std::multimap<TransformedKeyType, TransformedMappedType, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::container::map traits.
|
|
template<typename KEY, typename T, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::container::map<KEY, T, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::container::map<KEY, T, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::container::map<KEY, T, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef Boost::container::map<TransformedKeyType, TransformedMappedType, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::container::multimap traits.
|
|
template<typename KEY, typename T, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::container::multimap<KEY, T, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::container::multimap<KEY, T, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::container::multimap<KEY, T, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef Boost::container::multimap<TransformedKeyType, TransformedMappedType, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
#if (!defined ACTIV_BOOST_NO_CXX11_HDR_UNORDERED_MAP)
|
|
|
|
// std::unordered_map traits.
|
|
template<typename KEY, typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::unordered_map<KEY, T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::unordered_map<KEY, T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::unordered_map<KEY, T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef std::unordered_map<TransformedKeyType, TransformedMappedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// std::unordered_multimap traits.
|
|
template<typename KEY, typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<std::unordered_multimap<KEY, T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<std::unordered_multimap<KEY, T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<std::unordered_multimap<KEY, T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef std::unordered_multimap<TransformedKeyType, TransformedMappedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
#endif // (!defined ACTIV_BOOST_NO_CXX11_HDR_UNORDERED_MAP)
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::unordered_map traits.
|
|
template<typename KEY, typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::unordered_map<KEY, T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::unordered_map<KEY, T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::unordered_map<KEY, T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename Base::ContainerType::iterator, bool> EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef Boost::unordered_map<TransformedKeyType, TransformedMappedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::unordered_multimap traits.
|
|
template<typename KEY, typename T, typename HASH, typename COMPARE, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::unordered_multimap<KEY, T, HASH, COMPARE, ALLOCATOR> > :
|
|
public ContainerTraitsImplBase<Boost::unordered_multimap<KEY, T, HASH, COMPARE, ALLOCATOR> >
|
|
{
|
|
typedef ContainerTraitsImplBase<Boost::unordered_multimap<KEY, T, HASH, COMPARE, ALLOCATOR> > Base;
|
|
|
|
public:
|
|
typedef CxxYZ::false_type HasUniqueKeys;
|
|
typedef StdContainerHasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename Base::ContainerType::iterator EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<KEY>::type TransformedKeyType;
|
|
typedef typename TRANSFORM<T>::type TransformedMappedType;
|
|
typedef std::pair<const TransformedKeyType, TransformedMappedType> TransformedValueType;
|
|
|
|
public:
|
|
typedef Boost::unordered_multimap<TransformedKeyType, TransformedMappedType, HASH, COMPARE,
|
|
typename RebindAllocator<ALLOCATOR, TransformedValueType>::type> type;
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template<typename INDEX_SPECIFIER, typename INDEX>
|
|
class MultiIndexTraits;
|
|
|
|
template<typename ARG1, typename ARG2, typename ARG3, typename INDEX>
|
|
class MultiIndexTraits<Boost::multi_index::ordered_unique<ARG1, ARG2, ARG3>, INDEX>
|
|
{
|
|
public:
|
|
typedef CxxYZ::false_type IsSequence;
|
|
typedef CxxYZ::true_type IsAssociative;
|
|
typedef CxxYZ::false_type IsMapLike;
|
|
typedef CxxYZ::true_type HasUniqueKeys;
|
|
typedef CxxYZ::false_type HasRandomAccess;
|
|
typedef CxxYZ::false_type HasReserve;
|
|
typedef CxxYZ::true_type HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef std::pair<typename INDEX::iterator, bool> EmplaceResultType;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Boost::multi_index_container traits on primary index.
|
|
template<typename T, typename INDEX_SPECIFIER_LIST, typename ALLOCATOR>
|
|
class ContainerTraitsImpl<Boost::multi_index_container<T, INDEX_SPECIFIER_LIST, ALLOCATOR> >
|
|
{
|
|
public:
|
|
// TODO surely can get back to index specifier from index...
|
|
|
|
typedef Boost::multi_index_container<T, INDEX_SPECIFIER_LIST, ALLOCATOR> ContainerType;
|
|
|
|
private:
|
|
typedef typename Boost::mpl::at<typename ContainerType::index_specifier_type_list, Boost::mpl::int_<0> >::type
|
|
PrimaryIndexSpecifier;
|
|
typedef typename Boost::multi_index::nth_index<ContainerType, 0>::type PrimaryIndex;
|
|
typedef MultiIndexTraits<PrimaryIndexSpecifier, PrimaryIndex> PrimaryIndexTraits;
|
|
|
|
public:
|
|
typedef CxxYZ::true_type IsSupportedContainer;
|
|
typedef typename PrimaryIndexTraits::IsSequence IsSequence;
|
|
typedef typename PrimaryIndexTraits::IsMapLike IsMapLike;
|
|
typedef typename PrimaryIndexTraits::HasUniqueKeys HasUniqueKeys;
|
|
typedef typename PrimaryIndexTraits::HasRandomAccess HasRandomAccess;
|
|
typedef typename PrimaryIndexTraits::HasReserve HasReserve;
|
|
typedef typename PrimaryIndexTraits::HasEmplace HasEmplace;
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
typedef typename PrimaryIndexTraits::EmplaceResultType EmplaceResultType;
|
|
|
|
//! Create a new container type with a transformed value type.
|
|
template<template<typename> class TRANSFORM>
|
|
class Rebind
|
|
{
|
|
private:
|
|
typedef typename TRANSFORM<T>::type TransformedType;
|
|
|
|
public:
|
|
typedef Boost::multi_index_container<TransformedType, INDEX_SPECIFIER_LIST,
|
|
typename RebindAllocator<ALLOCATOR, TransformedType>::type> type;
|
|
};
|
|
};
|
|
|
|
} // namespace Detail
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
//! Is a type a container supported by this header?
|
|
template<typename T>
|
|
class IsSupported : public Detail::ContainerTraitsImpl<T>::IsSupportedContainer::type { };
|
|
|
|
//! Is a type a linear sequence container?
|
|
template<typename T>
|
|
class IsSequence : public Detail::ContainerTraitsImpl<T>::IsSequence::type { };
|
|
|
|
//! Is a type an associative container?
|
|
template<typename T>
|
|
class IsAssociative : public Detail::ContainerTraitsImpl<T>::IsAssociative::type { };
|
|
|
|
//! Is a type a map-like (key, value pair) container?
|
|
template<typename T>
|
|
class IsMapLike : public Detail::ContainerTraitsImpl<T>::IsMapLike::type { };
|
|
|
|
//! Does a container have unique keys (e.g. set, unordered_set)?
|
|
template<typename T>
|
|
class HasUniqueKeys : public Detail::ContainerTraitsImpl<T>::HasUniqueKeys::type { };
|
|
|
|
//! Does a container have random access to values (e.g. vector, deque)?
|
|
template<typename T>
|
|
class HasRandomAccess : public Detail::ContainerTraitsImpl<T>::HasRandomAccess::type { };
|
|
|
|
//! Does a type have a reserve(size) member function?
|
|
template<typename T>
|
|
class HasReserve : public Detail::ContainerTraitsImpl<T>::HasReserve::type { };
|
|
|
|
//! Does a type have an emplace(value_type) member function?
|
|
template<typename T>
|
|
class HasEmplace : public Detail::ContainerTraitsImpl<T>::HasEmplace::type { };
|
|
|
|
//! Result type of ContainerHelper::Emplace().
|
|
template<typename T>
|
|
class EmplaceResultType
|
|
{
|
|
public:
|
|
typedef typename Detail::ContainerTraitsImpl<T>::EmplaceResultType type;
|
|
};
|
|
|
|
//! Generate a new container type after transforming the contained type(s) of another container.
|
|
template<typename T, template<typename> class TRANSFORM>
|
|
class Rebind : public Detail::ContainerTraitsImpl<T>::template Rebind<TRANSFORM> { };
|
|
|
|
} // namespace ContainerTraits
|
|
|
|
} // namespace Activ
|
|
|
|
#endif // (!defined ACTIV_MISC_CONTAINER_TRAITS_H)
|