ceph/src/boost/boost/icl/split_interval_map.hpp

   1 /*-----------------------------------------------------------------------------+
   2 Copyright (c) 2007-2012: Joachim Faulhaber
   3 Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
   4 +------------------------------------------------------------------------------+
   5    Distributed under the Boost Software License, Version 1.0.
   6       (See accompanying file LICENCE.txt or copy at
   7            http://www.boost.org/LICENSE_1_0.txt)
   8 +-----------------------------------------------------------------------------*/
   9 #ifndef BOOST_ICL_SPLIT_INTERVAL_MAP_HPP_JOFA_000706
  10 #define BOOST_ICL_SPLIT_INTERVAL_MAP_HPP_JOFA_000706
  11
  12 #include <boost/icl/interval_set.hpp>
  13 #include <boost/icl/interval_map.hpp>
  14 #include <boost/icl/interval_base_map.hpp>
  15 #include <boost/icl/split_interval_set.hpp>
  16
  17 namespace boost{namespace icl
  18 {
  19
  20 /** \brief implements a map as a map of intervals - on insertion
  21     overlapping intervals are split and associated values are combined. */
  22 template
  23 <
  24     typename DomainT,
  25     typename CodomainT,
  26     class Traits = icl::partial_absorber,
  27     ICL_COMPARE Compare  = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT),
  28     ICL_COMBINE Combine  = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
  29     ICL_SECTION Section  = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT),
  30     ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
  31     ICL_ALLOC   Alloc    = std::allocator
  32 >
  33 class split_interval_map:
  34     public interval_base_map<split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
  35                              DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
  36 {
  37 public:
  38     typedef Traits traits;
  39     typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
  40     typedef       interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> joint_type;
  41     typedef type overloadable_type;
  42
  43     typedef interval_base_map <type,
  44                                DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
  45
  46     typedef DomainT domain_type;
  47     typedef CodomainT codomain_type;
  48     typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
  49     typedef typename base_type::iterator iterator;
  50     typedef typename base_type::value_type value_type;
  51     typedef typename base_type::element_type element_type;
  52     typedef typename base_type::segment_type segment_type;
  53     typedef typename base_type::domain_mapping_type    domain_mapping_type;
  54     typedef typename base_type::interval_mapping_type  interval_mapping_type;
  55     typedef typename base_type::ImplMapT ImplMapT;
  56
  57     typedef typename base_type::codomain_combine codomain_combine;
  58
  59     typedef interval_set<DomainT,Compare,Interval,Alloc> interval_set_type;
  60     typedef interval_set_type set_type;
  61     typedef set_type          key_object_type;
  62
  63     enum { fineness = 3 };
  64
  65 public:
  66     //==========================================================================
  67     //= Construct, copy, destruct
  68     //==========================================================================
  69     /// Default constructor for the empty object
  70     split_interval_map(): base_type() {}
  71
  72     /// Copy constructor
  73     split_interval_map(const split_interval_map& src): base_type(src) {}
  74
  75     explicit split_interval_map(const domain_mapping_type& base_pair): base_type()
  76     { this->add(base_pair); }
  77
  78     explicit split_interval_map(const value_type& value_pair): base_type()
  79     { this->add(value_pair); }
  80
  81     /// Assignment from a base interval_map.
  82     template<class SubType>
  83     void assign(const interval_base_map<SubType,DomainT,CodomainT,
  84                                         Traits,Compare,Combine,Section,Interval,Alloc>& src)
  85     {
  86         this->clear();
  87         this->_map.insert(src.begin(), src.end());
  88     }
  89
  90     /// Assignment operator for base type
  91     template<class SubType>
  92     split_interval_map& operator =
  93         (const interval_base_map<SubType,DomainT,CodomainT,
  94                                  Traits,Compare,Combine,Section,Interval,Alloc>& src)
  95     {
  96         this->assign(src);
  97         return *this;
  98     }
  99
 100 #   ifndef BOOST_ICL_NO_CXX11_RVALUE_REFERENCES
 101     //==========================================================================
 102     //= Move semantics
 103     //==========================================================================
 104
 105     /// Move constructor
 106     split_interval_map(split_interval_map&& src)
 107         : base_type(boost::move(src))
 108     {}
 109
 110     /// Move assignment operator
 111     split_interval_map& operator = (split_interval_map src)
 112     {
 113         base_type::operator=(boost::move(src));
 114         return *this;
 115     }
 116
 117     //==========================================================================
 118 #   else
 119
 120     /// Assignment operator
 121     split_interval_map& operator = (const split_interval_map& src)
 122     {
 123         base_type::operator=(src);
 124         return *this;
 125     }
 126
 127 #   endif // BOOST_ICL_NO_CXX11_RVALUE_REFERENCES
 128
 129 private:
 130     // Private functions that shall be accessible by the baseclass:
 131     friend class
 132         interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
 133                                               DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>;
 134
 135     iterator handle_inserted(iterator it_)const { return it_; }
 136     void handle_inserted(iterator, iterator)const{ }
 137
 138     template<class Combiner>
 139     void handle_left_combined(iterator it_)
 140     {
 141         if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
 142             this->_map.erase(it_);
 143     }
 144
 145     template<class Combiner>
 146     void handle_combined(iterator it_)
 147     {
 148         if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
 149             this->_map.erase(it_);
 150     }
 151
 152     template<class Combiner>
 153     void handle_preceeded_combined(iterator prior_, iterator& it_)
 154     {
 155         if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
 156         {
 157             this->_map.erase(it_);
 158             it_ = prior_;
 159         }
 160     }
 161
 162     template<class Combiner>
 163     void handle_succeeded_combined(iterator it_, iterator)
 164     {
 165         if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
 166             this->_map.erase(it_);
 167     }
 168
 169     void handle_reinserted(iterator){}
 170
 171     template<class Combiner>
 172     void gap_insert_at(iterator& it_, iterator prior_,
 173                        const interval_type& end_gap, const codomain_type& co_val)
 174     {
 175         if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable((*it_).second))
 176         {
 177             this->_map.erase(it_);
 178             it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
 179         }
 180         else
 181             it_ = this->template gap_insert<Combiner>(it_, end_gap, co_val);
 182     }
 183 } ;
 184
 185 //-----------------------------------------------------------------------------
 186 // type traits
 187 //-----------------------------------------------------------------------------
 188 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 189 struct is_map<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 190 {
 191     typedef is_map<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
 192     BOOST_STATIC_CONSTANT(bool, value = true);
 193 };
 194
 195 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 196 struct has_inverse<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 197 {
 198     typedef has_inverse<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
 199     BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
 200 };
 201
 202 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 203 struct is_interval_container<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 204 {
 205     typedef is_interval_container<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
 206     BOOST_STATIC_CONSTANT(bool, value = true);
 207 };
 208
 209 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 210 struct is_interval_splitter<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 211 {
 212     typedef is_interval_splitter<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
 213     BOOST_STATIC_CONSTANT(bool, value = true);
 214 };
 215
 216 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 217 struct absorbs_identities<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 218 {
 219     typedef absorbs_identities<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
 220     BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
 221 };
 222
 223 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 224 struct is_total<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 225 {
 226     typedef is_total<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
 227     BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total));
 228 };
 229
 230
 231 template <class DomainT, class CodomainT, class Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 232 struct type_to_string<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
 233 {
 234     static std::string apply()
 235     {
 236         return "sp_itv_map<"+ type_to_string<DomainT>::apply()   + ","
 237                             + type_to_string<CodomainT>::apply() + ","
 238                             + type_to_string<Traits>::apply()    +">";
 239     }
 240 };
 241
 242 }} // namespace icl boost
 243
 244 #endif
 245
 246