import new upstream nautilus stable release 14.2.8

[ceph.git] / ceph / src / boost / boost / icl / concept / element_associator.hpp

diff --git a/ceph/src/boost/boost/icl/concept/element_associator.hpp b/ceph/src/boost/boost/icl/concept/element_associator.hpp
index ce421e018cf439f8bde800bd86f93e86f6feb089..4d37e25ec2bbb905817f8b75b890cc8f4e009944 100644 (file)
--- a/ceph/src/boost/boost/icl/concept/element_associator.hpp
+++ b/ceph/src/boost/boost/icl/concept/element_associator.hpp
@@ -1,4 +1,4 @@
-/*-----------------------------------------------------------------------------+    
+/*-----------------------------------------------------------------------------+
 Copyright (c) 2010-2010: Joachim Faulhaber
 +------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
@@ -22,25 +22,25 @@ namespace boost{ namespace icl
 //==============================================================================
 //= Size
 //==============================================================================
-template<class Type> 
+template<class Type>
 typename enable_if<is_element_container<Type>, std::size_t>::type
 iterative_size(const Type& object)
-{ 
-    return object.size(); 
+{
+    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); 
+{
+    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); 
+{
+    return icl::iterative_size(object);
 }
 
 
@@ -54,15 +54,15 @@ cardinality(const Type& object)
 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()); 
+{
+    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> 
+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)
@@ -81,7 +81,7 @@ within(const SubT& sub, const SuperT& super)
     while(sub_ != sub.end())
     {
         super_ = super.find(key_value<SubT>(sub_));
-        if(super_ == super.end()) 
+        if(super_ == super.end())
             return false;
         else if(!co_equal(sub_, super_, &sub, &super))
             return false;
@@ -97,8 +97,8 @@ within(const SubT& sub, const SuperT& super)
 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); 
+{
+    return icl::within(key, super);
 }
 
 //------------------------------------------------------------------------------
@@ -109,15 +109,15 @@ 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); 
+{
+    return icl::within(sub, super);
 }
 
 //==============================================================================
 //= Equivalences and Orderings
 //==============================================================================
 
-#ifdef BOOST_MSVC 
+#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 :)
@@ -128,7 +128,7 @@ 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() 
+    return left.size() == right.size()
         && std::equal(left.begin(), left.end(), right.begin());
 }
 
@@ -148,17 +148,17 @@ 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(), 
+        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>, 
+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, 
+    return Set::subset_compare(left, right,
                                left.begin(), left.end(),
                                right.begin(), right.end());
 }
@@ -168,29 +168,29 @@ inclusion_compare(const LeftT& left, const RightT& right)
 //==============================================================================
 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); 
+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; 
+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; 
+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) 
-{ 
+operator += (Type& object, const Type& operand)
+{
     if(&object == &operand)
         return object;
 
@@ -203,45 +203,45 @@ operator += (Type& object, const Type& operand)
 
 template <class Type>
 inline typename enable_if<is_associative_element_container<Type>, Type>::type
-operator + (Type object, const Type& operand) 
-{ 
-    return object += operand; 
+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); 
+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; 
+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; 
+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; 
+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; 
+operator | (Type object, const Type& operand)
+{
+    return object += operand;
 }
 
 
@@ -252,7 +252,7 @@ operator | (Type object, const Type& operand)
 //- V insert(T&, c P&) T:{s}|{m} P:{e}|{b} fragment_type
 //------------------------------------------------------------------------------
 template<class Type>
-typename enable_if<is_associative_element_container<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)
 {
@@ -260,9 +260,9 @@ insert(Type& object, const typename Type::value_type& operand)
 }
 
 template<class Type>
-typename enable_if<is_associative_element_container<Type>, 
+typename enable_if<is_associative_element_container<Type>,
                    typename Type::iterator>::type
-insert(Type& object, typename Type::iterator      prior, 
+insert(Type& object, typename Type::iterator      prior,
                const typename Type::value_type& operand)
 {
     return object.insert(prior, operand);
@@ -278,10 +278,10 @@ insert(Type& object, const Type& addend)
     typedef typename Type::iterator iterator;
 
     iterator prior_ = object.end();
-    ICL_const_FORALL(typename Type, elem_, addend) 
+    ICL_const_FORALL(typename Type, elem_, addend)
         icl::insert(object, prior_, *elem_);
 
-    return object; 
+    return object;
 }
 
 
@@ -306,10 +306,10 @@ 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_); 
+    ICL_const_FORALL(typename Type, elem_, erasure)
+        icl::erase(object, *elem_);
 
-    return object; 
+    return object;
 }
 
 
@@ -319,33 +319,33 @@ erase(Type& object, const Type& erasure)
 //==============================================================================
 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); 
+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; 
+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) 
-{ 
+operator -= (Type& object, const Type& subtrahend)
+{
     ICL_const_FORALL(typename Type, it_, subtrahend)
         icl::subtract(object, *it_);
 
-    return object; 
+    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; 
+operator - (Type object, const Type& subtrahend)
+{
+    return object -= subtrahend;
 }
 
 
@@ -353,25 +353,25 @@ operator - (Type object, const Type& subtrahend)
 //= Intersection
 //==============================================================================
 //------------------------------------------------------------------------------
-//- void add_intersection(T&, c T&, c P&) T:{s}{m} P:{e}{e} key_type 
+//- 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, 
+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()) 
+    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 
+//- 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, 
+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;
@@ -386,12 +386,12 @@ add_intersection(Type& section, const Type& object,
 }
 
 //------------------------------------------------------------------------------
-//- Intersection<ElementMap|ElementSet> 
+//- 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);
@@ -415,7 +415,7 @@ operator & (const typename Type::key_type& operand, Type object)
 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);
@@ -458,7 +458,7 @@ template<class Type>
 inline typename enable_if<is_associative_element_container<Type>, Type>::type
 operator ^ (Type object, const Type& operand)
 {
-    return object ^= operand; 
+    return object ^= operand;
 }
 
 
@@ -472,7 +472,7 @@ erase_if(const Predicate& pred, Type& object)
     typename Type::iterator it_ = object.begin();
     while(it_ != object.end())
         if(pred(*it_))
-            icl::erase(object, it_++); 
+            icl::erase(object, it_++);
         else ++it_;
     return object;
 }
@@ -483,9 +483,9 @@ 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_++); 
-    
+        if(pred(*it_))
+            icl::add(object, *it_++);
+
     return object;
 }
 
@@ -502,5 +502,3 @@ assign_if(const Predicate& pred, Type& object, const Type& src)
 }} // namespace boost icl
 
 #endif
-
-