mirror of
https://github.com/yuzu-emu/ext-boost.git
synced 2025-01-05 17:05:42 +00:00
db95c7fe31
Keeps the boost libraries up to date. This also silences informational messages that get spammed throughout the build, such as: "Info: Boost.Config is older than your compiler version - probably nothing bad will happen - but you may wish to look for an update Boost version. Define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE to suppress this message." Which makes the compilation process a lot less noisy on Windows. It's now much easier to actually spot warnings that occur.
505 lines
17 KiB
C++
505 lines
17 KiB
C++
/*-----------------------------------------------------------------------------+
|
|
Copyright (c) 2010-2010: Joachim Faulhaber
|
|
+------------------------------------------------------------------------------+
|
|
Distributed under the Boost Software License, Version 1.0.
|
|
(See accompanying file LICENCE.txt or copy at
|
|
http://www.boost.org/LICENSE_1_0.txt)
|
|
+-----------------------------------------------------------------------------*/
|
|
#ifndef BOOST_ICL_CONCEPT_ELEMENT_ASSOCIATOR_HPP_JOFA_100921
|
|
#define BOOST_ICL_CONCEPT_ELEMENT_ASSOCIATOR_HPP_JOFA_100921
|
|
|
|
#include <boost/config.hpp>
|
|
#include <boost/icl/type_traits/is_associative_element_container.hpp>
|
|
#include <boost/icl/type_traits/is_key_container_of.hpp>
|
|
#include <boost/icl/type_traits/is_combinable.hpp>
|
|
#include <boost/icl/detail/subset_comparer.hpp>
|
|
#include <boost/icl/concept/element_set.hpp>
|
|
#include <boost/icl/concept/element_map.hpp>
|
|
|
|
namespace boost{ namespace icl
|
|
{
|
|
|
|
//==============================================================================
|
|
//= Size
|
|
//==============================================================================
|
|
template<class Type>
|
|
typename enable_if<is_element_container<Type>, std::size_t>::type
|
|
iterative_size(const Type& object)
|
|
{
|
|
return object.size();
|
|
}
|
|
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
|
|
size(const Type& object)
|
|
{
|
|
return icl::iterative_size(object);
|
|
}
|
|
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
|
|
cardinality(const Type& object)
|
|
{
|
|
return icl::iterative_size(object);
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
//= Containedness<ElementSet|ElementMap>
|
|
//==============================================================================
|
|
//------------------------------------------------------------------------------
|
|
//- bool within(c P&, c T&) T:{s}|{m} P:{e}|{i} fragment_types|key_types
|
|
//------------------------------------------------------------------------------
|
|
/** Checks if a key is in the associative container */
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, bool>::type
|
|
within(const typename Type::key_type& key, const Type& super)
|
|
{
|
|
return !(super.find(key) == super.end());
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//- bool within(c P&, c T&) T:{s}|{m} P:{s'} fragment_types|key_types
|
|
//------------------------------------------------------------------------------
|
|
template<class SubT, class SuperT>
|
|
typename enable_if<mpl::and_< is_associative_element_container<SuperT>
|
|
, is_key_container_of<SubT, SuperT> >,
|
|
bool>::type
|
|
within(const SubT& sub, const SuperT& super)
|
|
{
|
|
if(icl::is_empty(sub)) return true;
|
|
if(icl::is_empty(super)) return false;
|
|
if(icl::size(super) < icl::size(sub)) return false;
|
|
|
|
typename SubT::const_iterator common_lwb_;
|
|
typename SubT::const_iterator common_upb_;
|
|
if(!Set::common_range(common_lwb_, common_upb_, sub, super))
|
|
return false;
|
|
|
|
typename SubT::const_iterator sub_ = sub.begin();
|
|
typename SuperT::const_iterator super_;
|
|
while(sub_ != sub.end())
|
|
{
|
|
super_ = super.find(key_value<SubT>(sub_));
|
|
if(super_ == super.end())
|
|
return false;
|
|
else if(!co_equal(sub_, super_, &sub, &super))
|
|
return false;
|
|
|
|
++sub_;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//- bool contains(c T&, c P&) T:{s}|{m} P:{e}|{i} fragment_types|key_types
|
|
//------------------------------------------------------------------------------
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, bool>::type
|
|
contains(const Type& super, const typename Type::key_type& key)
|
|
{
|
|
return icl::within(key, super);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//- bool contains(c T&, c P&) T:{s}|{m} P:{s'} fragment_types|key_types
|
|
//------------------------------------------------------------------------------
|
|
template<class SubT, class SuperT>
|
|
typename enable_if<mpl::and_< is_associative_element_container<SuperT>
|
|
, is_key_container_of<SubT, SuperT> >,
|
|
bool>::type
|
|
contains(const SuperT& super, const SubT& sub)
|
|
{
|
|
return icl::within(sub, super);
|
|
}
|
|
|
|
//==============================================================================
|
|
//= Equivalences and Orderings
|
|
//==============================================================================
|
|
|
|
#ifdef BOOST_MSVC
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4996) //'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
|
|
#endif // I do guarantee here that I am using the parameters correctly :)
|
|
|
|
/** Standard equality, which is lexicographical equality of the sets
|
|
as sequences, that are given by their Compare order. */
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, bool>::type
|
|
operator == (const Type& left, const Type& right)
|
|
{
|
|
return left.size() == right.size()
|
|
&& std::equal(left.begin(), left.end(), right.begin());
|
|
}
|
|
|
|
#ifdef BOOST_MSVC
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, bool>::type
|
|
is_element_equal(const Type& left, const Type& right)
|
|
{ return left == right; }
|
|
|
|
|
|
/* Strict weak less ordering which is given by the Compare order */
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, bool>::type
|
|
operator < (const Type& left, const Type& right)
|
|
{
|
|
return std::lexicographical_compare(
|
|
left.begin(), left.end(), right.begin(), right.end(),
|
|
typename Type::element_compare()
|
|
);
|
|
}
|
|
|
|
template<class LeftT, class RightT>
|
|
typename enable_if<is_concept_equivalent<is_element_container,LeftT, RightT>,
|
|
int>::type
|
|
inclusion_compare(const LeftT& left, const RightT& right)
|
|
{
|
|
return Set::subset_compare(left, right,
|
|
left.begin(), left.end(),
|
|
right.begin(), right.end());
|
|
}
|
|
|
|
//==============================================================================
|
|
//= Addition
|
|
//==============================================================================
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator += (Type& object, const typename Type::value_type& operand)
|
|
{
|
|
return icl::add(object, operand);
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator + (Type object, const typename Type::value_type& operand)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator + (const typename Type::value_type& operand, Type object)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator += (Type& object, const Type& operand)
|
|
{
|
|
if(&object == &operand)
|
|
return object;
|
|
|
|
typename Type::iterator prior_ = object.end();
|
|
ICL_const_FORALL(typename Type, it_, operand)
|
|
prior_ = icl::add(object, prior_, *it_);
|
|
|
|
return object;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator + (Type object, const Type& operand)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
//==============================================================================
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator |= (Type& object, const typename Type::value_type& operand)
|
|
{
|
|
return icl::add(object, operand);
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator | (Type object, const typename Type::value_type& operand)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator | (const typename Type::value_type& operand, Type object)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator |= (Type& object, const Type& operand)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator | (Type object, const Type& operand)
|
|
{
|
|
return object += operand;
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
//= Insertion
|
|
//==============================================================================
|
|
//------------------------------------------------------------------------------
|
|
//- V insert(T&, c P&) T:{s}|{m} P:{e}|{b} fragment_type
|
|
//------------------------------------------------------------------------------
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>,
|
|
std::pair<typename Type::iterator,bool> >::type
|
|
insert(Type& object, const typename Type::value_type& operand)
|
|
{
|
|
return object.insert(operand);
|
|
}
|
|
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>,
|
|
typename Type::iterator>::type
|
|
insert(Type& object, typename Type::iterator prior,
|
|
const typename Type::value_type& operand)
|
|
{
|
|
return object.insert(prior, operand);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//- T insert(T&, c T&) T:{s m} map fragment_type
|
|
//------------------------------------------------------------------------------
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
insert(Type& object, const Type& addend)
|
|
{
|
|
typedef typename Type::iterator iterator;
|
|
|
|
iterator prior_ = object.end();
|
|
ICL_const_FORALL(typename Type, elem_, addend)
|
|
icl::insert(object, prior_, *elem_);
|
|
|
|
return object;
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
//= Erasure
|
|
//==============================================================================
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
|
|
erase(Type& object, const typename Type::key_type& key_value)
|
|
{
|
|
typedef typename Type::size_type size_type;
|
|
typename Type::iterator it_ = object.find(key_value);
|
|
if(it_ != object.end())
|
|
{
|
|
object.erase(it_);
|
|
return unit_element<size_type>::value();
|
|
}
|
|
return identity_element<size_type>::value();
|
|
}
|
|
|
|
template<class Type>
|
|
typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
erase(Type& object, const Type& erasure)
|
|
{
|
|
ICL_const_FORALL(typename Type, elem_, erasure)
|
|
icl::erase(object, *elem_);
|
|
|
|
return object;
|
|
}
|
|
|
|
|
|
|
|
//==============================================================================
|
|
//= Subtraction<ElementSet|ElementMap>
|
|
//==============================================================================
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator -= (Type& object, const typename Type::value_type& operand)
|
|
{
|
|
return icl::subtract(object, operand);
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator - (Type object, const typename Type::value_type& operand)
|
|
{
|
|
return object -= operand;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator -= (Type& object, const Type& subtrahend)
|
|
{
|
|
ICL_const_FORALL(typename Type, it_, subtrahend)
|
|
icl::subtract(object, *it_);
|
|
|
|
return object;
|
|
}
|
|
|
|
template <class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator - (Type object, const Type& subtrahend)
|
|
{
|
|
return object -= subtrahend;
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
//= Intersection
|
|
//==============================================================================
|
|
//------------------------------------------------------------------------------
|
|
//- void add_intersection(T&, c T&, c P&) T:{s}{m} P:{e}{e} key_type
|
|
//------------------------------------------------------------------------------
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, void>::type
|
|
add_intersection(Type& section, const Type& object,
|
|
const typename Type::key_type& operand)
|
|
{
|
|
typedef typename Type::const_iterator const_iterator;
|
|
const_iterator it_ = object.find(operand);
|
|
if(it_ != object.end())
|
|
icl::add(section, *it_);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//- void add_intersection(T&, c T&, c P&) T:{s}{m} P:{s}{s} set key_type
|
|
//------------------------------------------------------------------------------
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, void>::type
|
|
add_intersection(Type& section, const Type& object,
|
|
const typename key_container_type_of<Type>::type& operand)
|
|
{
|
|
typedef typename key_container_type_of<Type>::type key_container_type;
|
|
typedef typename key_container_type::const_iterator const_iterator;
|
|
const_iterator common_lwb_, common_upb_;
|
|
if(!Set::common_range(common_lwb_, common_upb_, operand, object))
|
|
return;
|
|
|
|
const_iterator sec_ = common_lwb_;
|
|
while(sec_ != common_upb_)
|
|
add_intersection(section, object, *sec_++);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//- Intersection<ElementMap|ElementSet>
|
|
//------------------------------------------------------------------------------
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator &= (Type& object, const typename Type::key_type& operand)
|
|
{
|
|
Type section;
|
|
add_intersection(section, object, operand);
|
|
object.swap(section);
|
|
return object;
|
|
}
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator & (Type object, const typename Type::key_type& operand)
|
|
{
|
|
return object &= operand;
|
|
}
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator & (const typename Type::key_type& operand, Type object)
|
|
{
|
|
return object &= operand;
|
|
}
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
operator &= (Type& object, const typename key_container_type_of<Type>::type& operand)
|
|
{
|
|
Type section;
|
|
add_intersection(section, object, operand);
|
|
object.swap(section);
|
|
return object;
|
|
}
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator & (Type object, const Type& operand)
|
|
{
|
|
return object &= operand;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class Type, class CoType>
|
|
inline typename enable_if<is_associative_element_container<Type>, bool>::type
|
|
disjoint(const Type& left, const Type& right)
|
|
{
|
|
return !intersects(left, right);
|
|
}
|
|
|
|
//==============================================================================
|
|
//= Symmetric difference<ElementSet|ElementMap>
|
|
//==============================================================================
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator ^ (Type object, const typename Type::value_type& operand)
|
|
{
|
|
return icl::flip(object, operand);
|
|
}
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator ^ (const typename Type::value_type& operand, Type object)
|
|
{
|
|
return icl::flip(object, operand);
|
|
}
|
|
|
|
template<class Type>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type
|
|
operator ^ (Type object, const Type& operand)
|
|
{
|
|
return object ^= operand;
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
//= Manipulation by predicates
|
|
//==============================================================================
|
|
template<class Type, class Predicate>
|
|
typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
erase_if(const Predicate& pred, Type& object)
|
|
{
|
|
typename Type::iterator it_ = object.begin();
|
|
while(it_ != object.end())
|
|
if(pred(*it_))
|
|
icl::erase(object, it_++);
|
|
else ++it_;
|
|
return object;
|
|
}
|
|
|
|
template<class Type, class Predicate>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
add_if(const Predicate& pred, Type& object, const Type& src)
|
|
{
|
|
typename Type::const_iterator it_ = src.begin();
|
|
while(it_ != src.end())
|
|
if(pred(*it_))
|
|
icl::add(object, *it_++);
|
|
|
|
return object;
|
|
}
|
|
|
|
template<class Type, class Predicate>
|
|
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
|
|
assign_if(const Predicate& pred, Type& object, const Type& src)
|
|
{
|
|
icl::clear(object);
|
|
return add_if(object, src, pred);
|
|
}
|
|
|
|
|
|
|
|
}} // namespace boost icl
|
|
|
|
#endif
|