Class template interval_map

Boost C++ Libraries

Class template interval_map

boost::itl::interval_map — implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined.

Synopsis

template<typename DomainT , typename CodomainT , 
         class Traits  = itl::partial_absorber, 
         ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), 
         ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), 
         ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), 
         template< class, ITL_COMPARE >class Interval = itl::interval, 
         ITL_ALLOC Alloc = std::allocator> 
class interval_map : public boost::itl::interval_base_map< boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
{
public:
  // types
  typedef Traits                                                                                                                                                                              traits;                 // Traits of an itl map. 
  typedef interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >                                                                                              type;                 
  typedef split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >                                                                                        split_type;           
  typedef type                                                                                                                                                                                overloadable_type;      // Auxilliary type for overloadresolution. 
  typedef type                                                                                                                                                                                joint_type;           
  typedef interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > base_type;            
  typedef Interval< DomainT, Compare >                                                                                                                                                        interval_type;          // The interval type of the map. 
  typedef base_type::iterator                                                                                                                                                                 iterator;               // iterator for iteration over intervals 
  typedef base_type::value_type                                                                                                                                                               value_type;             // value type of the implementing container 
  typedef base_type::element_type                                                                                                                                                             element_type;           // Conceptual is a map a set of elements of type element_type. 
  typedef base_type::segment_type                                                                                                                                                             segment_type;           // Type of an interval containers segment, that is spanned by an interval. 
  typedef base_type::domain_mapping_type                                                                                                                                                      domain_mapping_type;    // Auxiliary type to help the compiler resolve ambiguities when using std::make_pair. 
  typedef base_type::interval_mapping_type                                                                                                                                                    interval_mapping_type;  // Auxiliary type for overload resolution. 
  typedef base_type::ImplMapT                                                                                                                                                                 ImplMapT;               // Container type for the implementation. 
  typedef base_type::codomain_combine                                                                                                                                                         codomain_combine;     
  typedef interval_set< DomainT, Compare, Interval, Alloc >                                                                                                                                   interval_set_type;    
  typedef interval_set_type                                                                                                                                                                   set_type;             

  // construct/copy/destruct
  interval_map();
  interval_map(const interval_map &);
  template<class SubType > 
    interval_map(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
  interval_map(domain_mapping_type &);
  interval_map(const value_type &);
  template<class SubType > 
    interval_map& 
    operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);

  // public member functions
  template<class SubType > 
    void assign(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &) ;

  // private member functions
  bool contains_(const value_type &) const;
  template<class Combiner > void add_(const value_type &) ;
  template<class Combiner > iterator add_(iterator, const value_type &) ;
  template<class Combiner > void subtract_(const value_type &) ;
  void insert_(const value_type &) ;
  iterator insert_(iterator, const value_type &) ;
  void erase_(const value_type &) ;
  bool insertable(const value_type &) const;
  iterator join_left(iterator &) ;
  iterator join_right(iterator &) ;
  iterator join_neighbours(iterator &) ;
  bool joinable(const iterator &, const iterator &) const;
  iterator join_on_left(iterator &, const iterator &) ;
  iterator join_on_right(const iterator &, iterator &) ;
  template<class Combiner > 
    void add_main(interval_type &, const CodomainT &, iterator &, 
                  const iterator &) ;
  template<class Combiner > 
    void add_rear(const interval_type &, const CodomainT &, iterator &) ;
  void add_front(const interval_type &, iterator &) ;
  template<class Combiner > 
    void add_segment(const interval_type &, const CodomainT &, iterator &) ;
  template<class Combiner > 
    void subtract_main(const CodomainT &, iterator &, iterator &) ;
  void subtract_front(const interval_type &, const CodomainT &, iterator &) ;
  template<class Combiner > 
    void subtract_rear(const interval_type &, const CodomainT &, iterator &) ;
  void insert_range(const interval_type &, const CodomainT &, iterator &, 
                    iterator &) ;
  void erase_rest(const interval_type &, const CodomainT &, iterator &, 
                  iterator &) ;
};

Description

`interval_map` public construct/copy/destruct

```
interval_map();
```
```
interval_map(const interval_map & src);
```

template<class SubType > 
  interval_map(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);

interval_map(domain_mapping_type & base_pair);

interval_map(const value_type & value_pair);

template<class SubType > 
  interval_map& 
  operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);

`interval_map` public member functions

template<class SubType > 
  void assign(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src) ;

`interval_map` private member functions

bool contains_(const value_type & x) const;

template<class Combiner > void add_(const value_type &) ;

template<class Combiner > iterator add_(iterator prior_, const value_type &) ;

template<class Combiner > void subtract_(const value_type &) ;

void insert_(const value_type & value) ;

iterator insert_(iterator prior_, const value_type & value) ;

```
void erase_(const value_type & value) ;
```

bool insertable(const value_type & value) const;

```
iterator join_left(iterator & it_) ;
```
```
iterator join_right(iterator & it_) ;
```

iterator join_neighbours(iterator & it_) ;

bool joinable(const iterator & some, const iterator & next) const;

iterator join_on_left(iterator & some, const iterator & next) ;

iterator join_on_right(const iterator & some, iterator & next) ;

template<class Combiner > 
  void add_main(interval_type & inter_val, const CodomainT & co_val, 
                iterator & it_, const iterator & last_) ;

template<class Combiner > 
  void add_rear(const interval_type & inter_val, const CodomainT & co_val, 
                iterator & it_) ;

void add_front(const interval_type & inter_val, iterator & first_) ;

template<class Combiner > 
  void add_segment(const interval_type & inter_val, const CodomainT & co_val, 
                   iterator & it_) ;

template<class Combiner > 
  void subtract_main(const CodomainT & co_val, iterator & it_, 
                     iterator & end_) ;

void subtract_front(const interval_type & inter_val, const CodomainT & co_val, 
                    iterator & it_) ;

template<class Combiner > 
  void subtract_rear(const interval_type & inter_val, 
                     const CodomainT & co_val, iterator & it_) ;

void insert_range(const interval_type & inter_val, const CodomainT & co_val, 
                  iterator & it_, iterator & end_) ;

void erase_rest(const interval_type & inter_val, const CodomainT & co_val, 
                iterator & it_, iterator & last_) ;