ceph/src/boost/boost/icl/separate_interval_set.hpp

   1 /*-----------------------------------------------------------------------------+
   2 Copyright (c) 2007-2009: Joachim Faulhaber
   3 +------------------------------------------------------------------------------+
   4    Distributed under the Boost Software License, Version 1.0.
   5       (See accompanying file LICENCE.txt or copy at
   6            http://www.boost.org/LICENSE_1_0.txt)
   7 +-----------------------------------------------------------------------------*/
   8 #ifndef BOOST_ICL_SEPARATE_INTERVAL_SET_HPP_JOFA_080608
   9 #define BOOST_ICL_SEPARATE_INTERVAL_SET_HPP_JOFA_080608
  10
  11 #include <boost/assert.hpp>
  12 #include <boost/icl/type_traits/is_interval_separator.hpp>
  13 #include <boost/icl/interval_base_set.hpp>
  14 #include <boost/icl/interval_set.hpp>
  15
  16 namespace boost{namespace icl
  17 {
  18
  19 /** \brief Implements a set as a set of intervals - leaving adjoining intervals separate */
  20 template
  21 <
  22     typename                         DomainT,
  23     ICL_COMPARE                      Compare  = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT),
  24     ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
  25     ICL_ALLOC                        Alloc    = std::allocator
  26 >
  27 class separate_interval_set:
  28     public interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
  29                              DomainT,Compare,Interval,Alloc>
  30 {
  31 public:
  32     typedef separate_interval_set<DomainT,Compare,Interval,Alloc> type;
  33
  34     typedef interval_base_set<type,DomainT,Compare,Interval,Alloc> base_type;
  35
  36     typedef type overloadable_type;
  37     typedef type key_object_type;
  38
  39     typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
  40
  41     /// The domain type of the set
  42     typedef DomainT   domain_type;
  43     /// The codomaintype is the same as domain_type
  44     typedef DomainT   codomain_type;
  45
  46     /// The element type of the set
  47     typedef DomainT   element_type;
  48     /// The interval type of the set
  49     typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
  50     /// The segment type of the set
  51     typedef interval_type   segment_type;
  52
  53     /// Comparison functor for domain values
  54     typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
  55     /// Comparison functor for intervals
  56     typedef exclusive_less_than<interval_type> interval_compare;
  57
  58     /// Comparison functor for keys
  59     typedef exclusive_less_than<interval_type> key_compare;
  60
  61     /// The allocator type of the set
  62     typedef Alloc<interval_type> allocator_type;
  63
  64     /// allocator type of the corresponding element set
  65     typedef Alloc<DomainT> domain_allocator_type;
  66
  67     /// The corresponding atomized type representing this interval container of elements
  68     typedef typename base_type::atomized_type atomized_type;
  69
  70     /// Container type for the implementation
  71     typedef typename base_type::ImplSetT ImplSetT;
  72
  73     /// key type of the implementing container
  74     typedef typename ImplSetT::key_type   key_type;
  75     /// data type of the implementing container
  76     typedef typename ImplSetT::value_type data_type;
  77     /// value type of the implementing container
  78     typedef typename ImplSetT::value_type value_type;
  79
  80     /// iterator for iteration over intervals
  81     typedef typename ImplSetT::iterator iterator;
  82     /// const_iterator for iteration over intervals
  83     typedef typename ImplSetT::const_iterator const_iterator;
  84
  85     enum { fineness = 2 };
  86
  87 public:
  88     //==========================================================================
  89     //= Construct, copy, destruct
  90     //==========================================================================
  91     /// Default constructor for the empty object
  92     separate_interval_set(): base_type() {}
  93     /// Copy constructor
  94     separate_interval_set(const separate_interval_set& src): base_type(src) {}
  95
  96     /// Copy constructor for base_type
  97     template<class SubType>
  98     separate_interval_set
  99         (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
 100     {
 101         this->assign(src);
 102     }
 103
 104     /// Constructor for a single element
 105     explicit separate_interval_set(const domain_type& elem): base_type() { this->add(elem); }
 106     /// Constructor for a single interval
 107     explicit separate_interval_set(const interval_type& itv): base_type() { this->add(itv); }
 108
 109     /// Assignment from a base interval_set.
 110     template<class SubType>
 111     void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
 112     {
 113         this->clear();
 114         this->_set.insert(src.begin(), src.end());
 115     }
 116
 117     /// Assignment operator for base type
 118     template<class SubType>
 119     separate_interval_set& operator =
 120         (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
 121     {
 122         this->assign(src);
 123         return *this;
 124     }
 125
 126 #   ifndef BOOST_ICL_NO_CXX11_RVALUE_REFERENCES
 127     //==========================================================================
 128     //= Move semantics
 129     //==========================================================================
 130
 131     /// Move constructor
 132     separate_interval_set(separate_interval_set&& src)
 133         : base_type(boost::move(src))
 134     {}
 135
 136     /// Move assignment operator
 137     separate_interval_set& operator = (separate_interval_set src)
 138     {
 139         base_type::operator=(boost::move(src));
 140         return *this;
 141     }
 142     //==========================================================================
 143 #   else
 144
 145     /// Assignment operator
 146     separate_interval_set& operator = (const separate_interval_set& src)
 147     {
 148         base_type::operator=(src);
 149         return *this;
 150     }
 151
 152 #   endif // BOOST_ICL_NO_CXX11_RVALUE_REFERENCES
 153
 154 private:
 155     // Private functions that shall be accessible by the baseclass:
 156     friend class
 157         interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
 158                                                 DomainT,Compare,Interval,Alloc>;
 159
 160     iterator handle_inserted(iterator inserted_)
 161     {
 162         return inserted_;
 163     }
 164
 165     iterator add_over(const interval_type& addend, iterator last_)
 166     {
 167         return segmental::join_under(*this, addend, last_);
 168     }
 169
 170     iterator add_over(const interval_type& addend)
 171     {
 172         return segmental::join_under(*this, addend);
 173     }
 174
 175 } ;
 176
 177
 178
 179 //-----------------------------------------------------------------------------
 180 // type traits
 181 //-----------------------------------------------------------------------------
 182 template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 183 struct is_set<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
 184 {
 185     typedef is_set<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
 186     BOOST_STATIC_CONSTANT(bool, value = true);
 187 };
 188
 189 template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 190 struct is_interval_container<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
 191 {
 192     typedef is_interval_container<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
 193     BOOST_STATIC_CONSTANT(bool, value = true);
 194 };
 195
 196 template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 197 struct is_interval_separator<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
 198 {
 199     typedef is_interval_separator<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
 200     BOOST_STATIC_CONSTANT(bool, value = true);
 201 };
 202
 203 //-----------------------------------------------------------------------------
 204 // type representation
 205 //-----------------------------------------------------------------------------
 206 template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
 207 struct type_to_string<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
 208 {
 209     static std::string apply()
 210     { return "se_itv_set<"+ type_to_string<DomainT>::apply() +">"; }
 211 };
 212
 213 }} // namespace icl boost
 214
 215 #endif
 216
 217