| Home | Libraries | People | FAQ | More

## Class template split_interval_map

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

## Synopsis

    // In header: <boost/icl/interval_map.hpp>

    template<typename DomainT, typename CodomainT, typename Traits,
             ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section,
             ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc>
    class split_interval_map : public boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
    {
    public:
      // construct/copy/destruct
      split_interval_map();
      split_interval_map(const split_interval_map &);
      explicit split_interval_map(const domain_mapping_type &);
      explicit split_interval_map(const value_type &);
      split_interval_map(split_interval_map &&);
      template<typename SubType>
        split_interval_map &
        operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
      split_interval_map & operator=(split_interval_map);

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

      // private member functions
      iterator handle_inserted(iterator) const;
      void handle_inserted(iterator, iterator) const;
      template<typename Combiner> void handle_left_combined(iterator);
      template<typename Combiner> void handle_combined(iterator);
      template<typename Combiner>
        void handle_preceeded_combined(iterator, iterator &);
      template<typename Combiner>
        void handle_succeeded_combined(iterator, iterator);
      void handle_reinserted(iterator);
      template<typename Combiner>
        void gap_insert_at(iterator &, iterator, const interval_type &,
                           const codomain_type &);
    };

## Description

### `split_interval_map` public construct/copy/destruct

1.     split_interval_map();

   Default constructor for the empty object.

2.     split_interval_map(const split_interval_map & src);

   Copy constructor.

3.     explicit split_interval_map(const domain_mapping_type & base_pair);

4.     explicit split_interval_map(const value_type & value_pair);

5.     split_interval_map(split_interval_map && src);

   Move constructor.

6.     template<typename SubType>
         split_interval_map &
         operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);

   Assignment operator for base type.

7.     split_interval_map & operator=(split_interval_map src);

   Move assignment operator.

### `split_interval_map` public member functions

1.     typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);

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

   Assignment from a base `interval_map`.

### `split_interval_map` private member functions

1.     iterator handle_inserted(iterator it_) const;

2.     void handle_inserted(iterator, iterator) const;

3.     template<typename Combiner> void handle_left_combined(iterator it_);

4.     template<typename Combiner> void handle_combined(iterator it_);

5.     template<typename Combiner>
         void handle_preceeded_combined(iterator prior_, iterator & it_);

6.     template<typename Combiner>
         void handle_succeeded_combined(iterator it_, iterator);

7.     void handle_reinserted(iterator);

8.     template<typename Combiner>
         void gap_insert_at(iterator & it_, iterator prior_,
                            const interval_type & end_gap,
                            const codomain_type & co_val);