Reimport boost/icl as a separate project

CMakeLists.darwin.txt

@@ -975,6 +975,7 @@ add_subdirectory(ydb/library/yql/udfs/common/json2)
 add_subdirectory(ydb/library/yql/minikql/jsonpath)
 add_subdirectory(library/cpp/regex/hyperscan)
 add_subdirectory(contrib/libs/hyperscan)
+add_subdirectory(contrib/restricted/boost/icl)
 add_subdirectory(contrib/restricted/boost/libs/graph)
 add_subdirectory(contrib/restricted/boost/filesystem)
 add_subdirectory(contrib/libs/hyperscan/runtime_core2)

CMakeLists.linux.txt

@@ -974,6 +974,7 @@ add_subdirectory(library/cpp/hyperloglog)
 add_subdirectory(ydb/library/yql/udfs/common/hyperscan)
 add_subdirectory(library/cpp/regex/hyperscan)
 add_subdirectory(contrib/libs/hyperscan)
+add_subdirectory(contrib/restricted/boost/icl)
 add_subdirectory(contrib/restricted/boost/libs/graph)
 add_subdirectory(contrib/restricted/boost/filesystem)
 add_subdirectory(contrib/libs/hyperscan/runtime_core2)

contrib/libs/hyperscan/CMakeLists.txt

@@ -20,6 +20,7 @@ target_include_directories(contrib-libs-hyperscan PRIVATE
 target_link_libraries(contrib-libs-hyperscan PUBLIC
   contrib-libs-cxxsupp
   contrib-restricted-boost
+  restricted-boost-icl
   boost-libs-graph
 )
 target_sources(contrib-libs-hyperscan PRIVATE

contrib/restricted/boost/boost/icl/associative_element_container.hpp

@@ -1,20 +0,0 @@
-/*-----------------------------------------------------------------------------+    
-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_ASSOCIATIVE_ELEMENT_CONTAINER_HPP_JOFA_101023
-#define BOOST_ICL_ASSOCIATIVE_ELEMENT_CONTAINER_HPP_JOFA_101023
-
-#include <boost/icl/detail/map_algo.hpp>
-#include <boost/icl/concept/comparable.hpp>
-#include <boost/icl/concept/container.hpp>
-#include <boost/icl/concept/element_set.hpp>
-#include <boost/icl/concept/element_map.hpp>
-#include <boost/icl/concept/element_associator.hpp>
-
-#endif
-
-

contrib/restricted/boost/boost/icl/concept/element_associator.hpp

@@ -1,506 +0,0 @@
-/*-----------------------------------------------------------------------------+    
-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
-
-

contrib/restricted/boost/boost/icl/concept/element_map.hpp

@@ -1,481 +0,0 @@
-/*-----------------------------------------------------------------------------+    
-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_MAP_HPP_JOFA_100921
-#define BOOST_ICL_CONCEPT_ELEMENT_MAP_HPP_JOFA_100921
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/icl/detail/on_absorbtion.hpp>
-#include <boost/icl/type_traits/unit_element.hpp>
-#include <boost/icl/type_traits/is_total.hpp>
-#include <boost/icl/type_traits/absorbs_identities.hpp>
-#include <boost/icl/type_traits/is_associative_element_container.hpp>
-#include <boost/icl/type_traits/is_combinable.hpp>
-
-#include <boost/icl/concept/map_value.hpp>
-#include <boost/icl/detail/map_algo.hpp>
-
-
-namespace boost{ namespace icl
-{
-
-//NOTE: Some forward declarations are needed by some compilers.
-template<class Type, class Predicate>
-typename enable_if<is_associative_element_container<Type>, Type>::type&
-erase_if(const Predicate& pred, Type& object);
-
-
-//==============================================================================
-//= Containedness<ElementMap>
-//==============================================================================
-//------------------------------------------------------------------------------
-//- bool within(c P&, c T&) T:{m} P:{b} fragment_types
-//------------------------------------------------------------------------------
-/** Checks if a key-value pair is in the map */
-template<class Type>
-typename enable_if<is_element_map<Type>, bool>::type
-within(const typename Type::element_type& value_pair, const Type& super)
-{ 
-    typedef typename Type::const_iterator const_iterator;
-    const_iterator found_ = super.find(value_pair.first);
-    return found_ != super.end() && (*found_).second == value_pair.second;
-}
-
-//------------------------------------------------------------------------------
-//- bool contains(c T&, c P&) T:{m} P:{b} fragment_types
-//------------------------------------------------------------------------------
-template<class Type>
-typename enable_if<is_element_map<Type>, bool>::type
-contains(const Type& super, const typename Type::element_type& value_pair)
-{
-    return icl::within(value_pair, super);
-}
-
-//==============================================================================
-//= Equivalences and Orderings<ElementMap>
-//==============================================================================
-
-/** Protonic equality is equality on all elements that do not carry an identity element as content. */
-template<class Type>
-inline typename enable_if<is_element_map<Type>, bool>::type
-is_distinct_equal(const Type& lhs, const Type& rhs)
-{
-    return Map::lexicographical_distinct_equal(lhs, rhs);
-}
-
-//==============================================================================
-//= Addition<ElementMap>
-//==============================================================================
-/** \c add inserts \c value_pair into the map if it's key does 
-    not exist in the map.    
-    If \c value_pairs's key value exists in the map, it's data
-    value is added to the data value already found in the map. */
-template <class Type>
-typename enable_if<is_element_map<Type>, Type>::type&
-add(Type& object, const typename Type::value_type& value_pair)
-{
-    return object.add(value_pair); 
-}
-
-/** \c add add \c value_pair into the map using \c prior as a hint to
-    insert \c value_pair after the position \c prior is pointing to. */
-template <class Type>
-typename enable_if<is_element_map<Type>, typename Type::iterator>::type
-add(Type& object, typename Type::iterator prior, 
-    const typename Type::value_type& value_pair) 
-{ 
-    return object.add(prior, value_pair); 
-}
-
-//==============================================================================
-//= Erasure
-//==============================================================================
-//------------------------------------------------------------------------------
-//- T& erase(T&, c P&) T:{m} P:{b} fragment_type
-//------------------------------------------------------------------------------
-template <class Type>
-typename enable_if<is_element_map<Type>, typename Type::size_type>::type
-erase(Type& object, const typename Type::element_type& value_pair)
-{
-    typedef typename Type::size_type             size_type;
-    typedef typename Type::iterator              iterator;
-    typedef typename Type::on_identity_absorbtion on_identity_absorbtion;
-
-    if(on_identity_absorbtion::is_absorbable(value_pair.second)) 
-        return identity_element<size_type>::value();
-
-    iterator it_ = object.find(value_pair.first);
-    if(it_ != object.end() && value_pair.second == (*it_).second)
-    {
-        object.erase(it_);
-        return unit_element<size_type>::value();
-    }
-
-    return identity_element<size_type>::value();
-}
-
-template<class Type>
-typename enable_if<is_element_map<Type>, Type>::type&
-erase(Type& object, const typename Type::set_type& erasure)
-{
-    typedef typename Type::set_type set_type;
-    ICL_const_FORALL(typename set_type, elem_, erasure) 
-        icl::erase(object, *elem_); 
-
-    return object; 
-}
-
-//==============================================================================
-//= Subtraction
-//==============================================================================
-//------------------------------------------------------------------------------
-//- T& subtract(T&, c P&) T:{m} P:{b} fragment_type
-//------------------------------------------------------------------------------
-template <class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type&
-subtract(Type& object, const typename Type::element_type& operand) 
-{ 
-    return object.subtract(operand); 
-}
-
-//------------------------------------------------------------------------------
-//- T& subtract(T&, c P&) T:{m} P:{e} key_type
-//------------------------------------------------------------------------------
-template <class Type>
-typename enable_if<is_element_map<Type>, Type>::type&
-subtract(Type& object, const typename Type::domain_type& key_value)
-{
-    return icl::erase(object, key_value);
-}
-
-//------------------------------------------------------------------------------
-//- T& subtract(T&, c P&) T:{m} P:{s} set key_type 
-//------------------------------------------------------------------------------
-template <class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type&
-operator -= (Type& object, const typename Type::set_type& operand) 
-{ 
-    typedef typename Type::set_type           set_type;
-    typedef typename set_type::const_iterator co_iterator;
-    typedef typename Type::iterator           iterator;
-
-    co_iterator common_lwb_, common_upb_;
-    if(!Set::common_range(common_lwb_, common_upb_, operand, object))
-        return object;
-
-    co_iterator it_ = common_lwb_;
-    iterator    common_;
-
-    while(it_ != common_upb_)
-        object.erase(*it_++);
-
-    return object;
-}
-
-template <class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type
-operator - (Type object, const typename Type::set_type& subtrahend) 
-{ 
-    return object -= subtrahend; 
-}
-
-//==============================================================================
-//= Selective Update<ElementMap>
-//==============================================================================
-//------------------------------------------------------------------------------
-//- T& set_at(T&, c P&) T:{m} P:{b}
-//------------------------------------------------------------------------------
-template<class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type&
-set_at(Type& object, const typename Type::element_type& operand)
-{
-    typedef typename Type::iterator         iterator;
-    typedef typename Type::codomain_combine codomain_combine;
-    typedef on_absorbtion<Type,codomain_combine,absorbs_identities<Type>::value>
-                                            on_identity_absorbtion;
-
-    if(!on_identity_absorbtion::is_absorbable(operand.second))
-    {
-        std::pair<iterator,bool> insertion = object.insert(operand);
-        if(!insertion.second)
-            insertion->second = operand.second;
-    }
-    return object;
-}
-
-
-//==============================================================================
-//= Intersection
-//==============================================================================
-template<class Type>
-inline typename enable_if<is_element_map<Type>, void>::type
-add_intersection(Type& section, const Type&               object, 
-                       const typename Type::element_type& operand)
-{
-    object.add_intersection(section, operand);
-}
-
-template<class Type>
-inline typename enable_if<is_element_map<Type>, void>::type
-add_intersection(Type& section, const Type& object, const Type& operand)
-{
-    ICL_const_FORALL(typename Type, it_, operand) 
-        icl::add_intersection(section, object, *it_); 
-}
-
-//------------------------------------------------------------------------------
-//- T& op &=(T&, c P&) T:{m} P:{b m} fragment_types
-//------------------------------------------------------------------------------
-
-template<class Type>
-inline typename enable_if<mpl::and_<is_element_map<Type>, is_total<Type> >, Type>::type&
-operator &=(Type& object, const typename Type::element_type& operand)
-{
-    object.add(operand);
-    return object;
-}
-
-template<class Type>
-inline typename enable_if<mpl::and_<is_element_map<Type>, mpl::not_<is_total<Type> > >, Type>::type&
-operator &=(Type& object, const typename Type::element_type& operand)
-{
-    Type section;
-    icl::add_intersection(section, object, operand);
-    object.swap(section);
-    return object; 
-}
-
-template<class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type
-operator & (Type object, const typename Type::element_type& operand)
-{
-    return object &= operand;
-}
-
-template<class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type
-operator & (const typename Type::element_type& operand, Type object)
-{
-    return object &= operand;
-}
-
-
-template<class Type>
-inline typename enable_if<mpl::and_<is_element_map<Type>, is_total<Type> >, Type>::type&
-operator &=(Type& object, const Type& operand)
-{
-    object += operand; 
-    return object;
-}
-
-template<class Type>
-inline typename enable_if<mpl::and_<is_element_map<Type>, mpl::not_<is_total<Type> > >, Type>::type&
-operator &=(Type& object, const Type& operand)
-{
-    Type section;
-    icl::add_intersection(section, object, operand);
-    object.swap(section);
-    return object; 
-}
-
-template<class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type
-operator & (Type object, const typename Type::key_object_type& operand)
-{
-    return object &= operand;
-}
-
-template<class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type
-operator & (const typename Type::key_object_type& operand, Type object)
-{
-    return object &= operand;
-}
-
-//==============================================================================
-//= Intersection<ElementMap> bool intersects(x,y)
-//==============================================================================
-template<class Type, class CoType>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , is_total<Type>      > 
-                         , bool>::type
-intersects(const Type&, const CoType&)
-{
-    return true;
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , mpl::not_<is_total<Type> > > 
-                         , bool>::type
-intersects(const Type& object, const typename Type::domain_type& operand)
-{
-    return icl::contains(object, operand);
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , mpl::not_<is_total<Type> > > 
-                         , bool>::type
-intersects(const Type& object, const typename Type::set_type& operand)
-{
-    if(object.iterative_size() < operand.iterative_size())
-        return Map::intersects(object, operand);
-    else
-        return Map::intersects(operand, object);
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , mpl::not_<is_total<Type> > > 
-                         , bool>::type
-intersects(const Type& object, const typename Type::element_type& operand)
-{
-    Type intersection;
-    icl::add_intersection(intersection, object, operand);
-    return !intersection.empty();
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , mpl::not_<is_total<Type> > > 
-                         , bool>::type
-intersects(const Type& object, const Type& operand)
-{
-    if(object.iterative_size() < operand.iterative_size())
-        return Map::intersects(object, operand);
-    else
-        return Map::intersects(operand, object);
-}
-
-//==============================================================================
-//= Symmetric difference
-//==============================================================================
-template<class Type>
-inline typename enable_if<is_element_map<Type>, Type>::type&
-flip(Type& object, const typename Type::element_type& operand)
-{
-    return object.flip(operand);
-}
-
-template<class Type, class CoType>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , is_total<Type>       
-                                    , absorbs_identities<Type> > 
-                         , Type>::type&
-operator ^= (Type& object, const CoType&)
-{
-    icl::clear(object);
-    return object;
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , is_total<Type>       
-                                    , mpl::not_<absorbs_identities<Type> > > 
-                         , Type>::type&
-operator ^= (Type& object, const typename Type::element_type& operand)
-{
-    return object.flip(operand);
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , is_total<Type>       
-                                    , mpl::not_<absorbs_identities<Type> > > 
-                         , Type>::type&
-operator ^= (Type& object, const Type& operand)
-{
-    ICL_const_FORALL(typename Type, it_, operand)
-        icl::flip(object, *it_);
-
-    ICL_FORALL(typename Type, it2_, object)
-        (*it2_).second = identity_element<typename Type::codomain_type>::value();
-
-    return object;
-}
-
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , mpl::not_<is_total<Type> > > 
-                         , Type>::type&
-operator ^= (Type& object, const typename Type::element_type& operand)
-{
-    return icl::flip(object, operand);
-}
-
-template<class Type>
-inline typename enable_if< mpl::and_< is_element_map<Type>
-                                    , mpl::not_<is_total<Type> > > 
-                         , Type>::type&
-operator ^= (Type& object, const Type& operand)
-{
-    typedef typename Type::const_iterator const_iterator;
-    const_iterator it_ = operand.begin();
-    while(it_ != operand.end())
-        icl::flip(object, *it_++);
-
-    return object;
-}
-
-
-//==============================================================================
-//= Set selection
-//==============================================================================
-template<class Type>
-inline typename enable_if<is_element_map<Type>, 
-                          typename Type::set_type>::type&
-domain(typename Type::set_type& domain_set, const Type& object)
-{
-    typename Type::set_type::iterator prior_ = domain_set.end();
-    typename Type::const_iterator it_ = object.begin();
-    while(it_ != object.end())
-        prior_ = domain_set.insert(prior_, (*it_++).first);
-
-    return domain_set;
-}
-
-//==============================================================================
-//= Neutron absorbtion
-//==============================================================================
-template<class Type>
-inline typename enable_if<mpl::and_< is_element_map<Type>
-                                   , absorbs_identities<Type> >, Type>::type&
-absorb_identities(Type& object)
-{
-    typedef typename Type::element_type element_type;
-    return icl::erase_if(content_is_identity_element<element_type>(), object);
-}
-
-template<class Type>
-inline typename enable_if<mpl::and_< is_element_map<Type>
-                                   , mpl::not_<absorbs_identities<Type> > >
-                         , Type>::type&
-absorb_identities(Type&){}
-
-//==============================================================================
-//= Streaming<ElementMap>
-//==============================================================================
-template<class CharType, class CharTraits, class Type>
-inline typename enable_if<is_element_map<Type>, std::basic_ostream<CharType, CharTraits> >::type&
-operator << (std::basic_ostream<CharType, CharTraits>& stream, const Type& object)
-{
-    stream << "{";
-    ICL_const_FORALL(typename Type, it, object)
-        stream << "(" << it->first << "->" << it->second << ")";
-
-    return stream << "}";
-}
-
-
-}} // namespace boost icl
-
-#endif
-
-

contrib/restricted/boost/boost/icl/concept/element_set.hpp

@@ -1,134 +0,0 @@
-/*-----------------------------------------------------------------------------+    
-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_SET_HPP_JOFA_100921
-#define BOOST_ICL_CONCEPT_ELEMENT_SET_HPP_JOFA_100921
-
-#include <boost/icl/type_traits/is_combinable.hpp>
-#include <boost/icl/concept/set_value.hpp>
-#include <boost/icl/detail/std_set.hpp>
-#include <boost/icl/detail/set_algo.hpp>
-
-
-namespace boost{ namespace icl
-{
-
-//==============================================================================
-//= Addition<ElementSet>
-//==============================================================================
-/** \c add inserts \c operand into the map if it's key does 
-    not exist in the map.    
-    If \c operands's key value exists in the map, it's data
-    value is added to the data value already found in the map. */
-template <class Type>
-typename enable_if<is_element_set<Type>, Type>::type&
-add(Type& object, const typename Type::value_type& operand)
-{
-    object.insert(operand); 
-    return object;
-}
-
-/** \c add add \c operand into the map using \c prior as a hint to
-    insert \c operand after the position \c prior is pointing to. */
-template <class Type>
-typename enable_if<is_element_set<Type>, typename Type::iterator>::type
-add(Type& object, typename Type::iterator prior, 
-    const typename Type::value_type& operand) 
-{ 
-    return object.insert(prior, operand); 
-}
-
-//==============================================================================
-//= Subtraction
-//==============================================================================
-/** If the \c operand's key value is in the map, it's data value is
-    subtraced from the data value stored in the map. */
-template<class Type>
-typename enable_if<is_element_set<Type>, Type>::type&
-subtract(Type& object, const typename Type::value_type& operand)
-{
-    object.erase(operand);
-    return object;
-}
-
-
-//==============================================================================
-//= Intersection
-//==============================================================================
-template<class Type>
-inline typename enable_if<is_element_set<Type>, bool>::type
-intersects(const Type& object, const typename Type::key_type& operand)
-{
-    return !(object.find(operand) == object.end()); 
-}
-
-template<class Type>
-inline typename enable_if<is_element_set<Type>, bool>::type
-intersects(const Type& object, const Type& operand)
-{
-    if(iterative_size(object) < iterative_size(operand))
-        return Set::intersects(object, operand);
-    else
-        return Set::intersects(operand, object);
-}
-
-//==============================================================================
-//= Symmetric difference
-//==============================================================================
-template<class Type>
-inline typename enable_if<is_element_set<Type>, Type>::type&
-flip(Type& object, const typename Type::value_type& operand)
-{
-    typedef typename Type::iterator iterator;
-    std::pair<iterator,bool> insertion = object.insert(operand);
-    if(!insertion.second)
-        object.erase(insertion.first);
-
-    return object;
-}
-
-template<class Type>
-inline typename enable_if<is_element_set<Type>, Type>::type&
-operator ^= (Type& object, const typename Type::element_type& operand)
-{
-    return icl::flip(object, operand); 
-}
-
-/** Symmetric subtract map \c x2 and \c *this.
-    So \c *this becomes the symmetric difference of \c *this and \c x2 */
-template<class Type>
-inline typename enable_if<is_element_set<Type>, Type>::type&
-operator ^= (Type& object, const Type& operand)
-{
-    typedef typename Type::const_iterator const_iterator;
-    const_iterator it_ = operand.begin();
-    while(it_ != operand.end())
-        icl::flip(object, *it_++);
-
-    return object;
-}
-
-//==============================================================================
-//= Streaming<ElementSet>
-//==============================================================================
-template<class CharType, class CharTraits, class Type>
-inline typename enable_if<is_element_set<Type>, std::basic_ostream<CharType, CharTraits> >::type&
-operator << (std::basic_ostream<CharType, CharTraits>& stream, const Type& object)
-{
-    stream << "{";
-    ICL_const_FORALL(typename Type, it, object)
-        stream << (*it) << " ";
-
-    return stream << "}";
-}
-
-
-}} // namespace boost icl
-
-#endif
-
-

contrib/restricted/boost/boost/icl/concept/element_set_value.hpp

@@ -1,31 +0,0 @@
-/*-----------------------------------------------------------------------------+    
-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_SET_VALUE_HPP_JOFA_100924
-#define BOOST_ICL_CONCEPT_ELEMENT_SET_VALUE_HPP_JOFA_100924
-
-#include <boost/icl/type_traits/is_element_container.hpp>
-
-namespace boost{ namespace icl
-{
-
-//==============================================================================
-//= AlgoUnifiers<Set>
-//==============================================================================
-template<class Type, class Iterator>
-inline typename enable_if<is_element_set<Type>, const typename Type::key_type>::type&
-co_value(Iterator it_)
-{
-    return *it_;
-}
-
-
-}} // namespace boost icl
-
-#endif
-
-

contrib/restricted/boost/boost/icl/detail/interval_morphism.hpp

@@ -1,107 +0,0 @@
-/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: 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_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
-#define BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
-
-#include <boost/icl/detail/notate.hpp>
-#include <boost/icl/concept/interval_set_value.hpp>
-#include <boost/icl/concept/element_set_value.hpp>
-#include <boost/icl/concept/set_value.hpp>
-#include <boost/icl/concept/map_value.hpp>
-#include <boost/icl/associative_interval_container.hpp>
-#include <boost/icl/associative_element_container.hpp>
-
-namespace boost{namespace icl
-{
-    namespace segmental
-    {
-        template <typename ElementContainerT, typename IntervalContainerT>
-        void atomize(ElementContainerT& result, const IntervalContainerT& src)
-        {
-            ICL_const_FORALL(typename IntervalContainerT, itv_, src)
-            {
-                const typename IntervalContainerT::key_type& itv   = icl::key_value<IntervalContainerT>(itv_);
-                typename IntervalContainerT::codomain_type   coval = icl::co_value<IntervalContainerT>(itv_);
-
-                for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element)
-                    icl::insert(result, icl::make_value<ElementContainerT>(element, coval));
-            }
-        }
-
-        template <typename IntervalContainerT, typename ElementContainerT>
-        void cluster(IntervalContainerT& result, const ElementContainerT& src)
-        {
-            typedef typename IntervalContainerT::key_type key_type;
-            ICL_const_FORALL(typename ElementContainerT, element_, src)
-            {
-                const typename ElementContainerT::key_type&  key  
-                    = key_value<ElementContainerT>(element_);
-                const typename codomain_type_of<ElementContainerT>::type& coval 
-                    = co_value<ElementContainerT>(element_);
-
-                result += icl::make_value<IntervalContainerT>(key_type(key), coval);
-            }
-        }
-
-        template <typename AtomizedType, typename ClusteredType>
-        struct atomizer
-        {
-            void operator()(AtomizedType& atomized, const ClusteredType& clustered)
-            {
-                segmental::atomize(atomized, clustered);
-            }
-        };
-
-        template <typename ClusteredType, typename AtomizedType>
-        struct clusterer
-        {
-            void operator()(ClusteredType& clustered, const AtomizedType& atomized)
-            {
-                segmental::cluster(clustered, atomized);
-            }
-        };
-
-        template <typename JointType, typename SplitType>
-        struct joiner
-        {
-            void operator()(JointType& joint, SplitType& split)
-            {
-                icl::join(split);
-                ICL_FORALL(typename SplitType, split_, split)
-                    joint.insert(*split_);
-            }
-        };
-
-        template <typename AbsorberType, typename EnricherType>
-        struct identity_absorber
-        {
-            void operator()(AbsorberType& absorber, EnricherType& enricher)
-            {
-                icl::absorb_identities(enricher);
-                ICL_FORALL(typename EnricherType, enricher_, enricher)
-                    absorber.insert(*enricher_);
-            }
-        };
-
-    } // namespace Interval
-
-
-    template<> 
-    inline std::string binary_template_to_string<segmental::atomizer>::apply() { return "@"; }
-    template<> 
-    inline std::string binary_template_to_string<segmental::clusterer>::apply() { return "&"; }
-    template<> 
-    inline std::string binary_template_to_string<segmental::joiner>::apply() { return "j"; }
-    template<> 
-    inline std::string binary_template_to_string<segmental::identity_absorber>::apply() { return "a0"; }
-}} // namespace boost icl
-
-#endif // BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
-
-
-

contrib/restricted/boost/boost/icl/detail/on_absorbtion.hpp

@@ -1,43 +0,0 @@
-/*-----------------------------------------------------------------------------+    
-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_TYPE_TRAITS_ON_ABSORBTION_HPP_JOFA_100915
-#define BOOST_ICL_TYPE_TRAITS_ON_ABSORBTION_HPP_JOFA_100915
-
-namespace boost{ namespace icl
-{
-
-template<class Type, class Combiner, bool absorbs_identities>
-struct on_absorbtion;
-
-template<class Type, class Combiner>
-struct on_absorbtion<Type, Combiner, false>
-{
-    typedef on_absorbtion type;
-    typedef typename Type::codomain_type codomain_type;
-
-    static bool is_absorbable(const codomain_type&){ return false; }
-};
-
-template<class Type, class Combiner>
-struct on_absorbtion<Type, Combiner, true>
-{
-    typedef on_absorbtion type;
-    typedef typename Type::codomain_type codomain_type;
-    typedef typename Type::codomain_combine codomain_combine;
-
-    static bool is_absorbable(const codomain_type& co_value)
-    {
-        return co_value == Combiner::identity_element();
-    }
-};
-
-}} // namespace boost icl
-
-#endif
-
-