| Home | Libraries | People | FAQ | More

## Class template separate_interval_set

boost::icl::separate_interval_set — Implements a set as a set of intervals - leaving adjoining intervals separate.

## Synopsis

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

    template<typename DomainT,
             ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT),
             ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
             ICL_ALLOC Alloc = std::allocator>
    class separate_interval_set : public boost::icl::interval_base_set< boost::icl::separate_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >
    {
    public:
      // types
      typedef separate_interval_set< DomainT, Compare, Interval, Alloc >   type;
      typedef interval_base_set< type, DomainT, Compare, Interval, Alloc > base_type;
      typedef type                                                         overloadable_type;      // Auxilliary type for overloadresolution.
      typedef type                                                         key_object_type;
      typedef interval_set< DomainT, Compare, Interval, Alloc >            joint_type;
      typedef DomainT                                                      domain_type;            // The domain type of the set.
      typedef DomainT                                                      codomain_type;          // The codomaintype is the same as domain_type.
      typedef DomainT                                                      element_type;           // The element type of the set.
      typedef interval_type                                                segment_type;           // The segment type of the set.
      typedef exclusive_less_than< interval_type >                         interval_compare;       // Comparison functor for intervals.
      typedef exclusive_less_than< interval_type >                         key_compare;            // Comparison functor for keys.
      typedef Alloc< interval_type >                                       allocator_type;         // The allocator type of the set.
      typedef Alloc< DomainT >                                             domain_allocator_type;  // allocator type of the corresponding element set
      typedef base_type::atomized_type                                     atomized_type;          // The corresponding atomized type representing this interval container of elements.
      typedef base_type::ImplSetT                                          ImplSetT;               // Container type for the implementation.
      typedef ImplSetT::key_type                                           key_type;               // key type of the implementing container
      typedef ImplSetT::value_type                                         data_type;              // data type of the implementing container
      typedef ImplSetT::value_type                                         value_type;             // value type of the implementing container
      typedef ImplSetT::iterator                                           iterator;               // iterator for iteration over intervals
      typedef ImplSetT::const_iterator                                     const_iterator;         // const_iterator for iteration over intervals

      // construct/copy/destruct
      separate_interval_set();
      separate_interval_set(const separate_interval_set &);
      template<typename SubType>
        separate_interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &);
      explicit separate_interval_set(const domain_type &);
      explicit separate_interval_set(const interval_type &);
      separate_interval_set(separate_interval_set &&);
      separate_interval_set& operator=(const separate_interval_set &);
      template<typename SubType>
        separate_interval_set&
        operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &);
      separate_interval_set& operator=(separate_interval_set &&);

      // public member functions
      typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);
      typedef ICL_COMPARE_DOMAIN(Compare, DomainT);
      template<typename SubType>
        void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &);

      // private member functions
      iterator handle_inserted(iterator);
      iterator add_over(const interval_type &, iterator);
      iterator add_over(const interval_type &);
    };

## Description

### `separate_interval_set` public construct/copy/destruct

1.     separate_interval_set();

   Default constructor for the empty object.

2.     separate_interval_set(const separate_interval_set & src);

   Copy constructor.

3.     template<typename SubType>
         separate_interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);

   Copy constructor for base_type.

4.     explicit separate_interval_set(const domain_type & elem);

   Constructor for a single element.

5.     explicit separate_interval_set(const interval_type & itv);

   Constructor for a single interval.

6.     separate_interval_set(separate_interval_set && src);

   Move constructor.

7.     separate_interval_set& operator=(const separate_interval_set & src);

   Assignment operator.

8.     template<typename SubType>
         separate_interval_set&
         operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);

   Assignment operator for base type.

9.     separate_interval_set& operator=(separate_interval_set && src);

   Move assignment operator.

### `separate_interval_set` public member functions

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

   The interval type of the set.

2.     typedef ICL_COMPARE_DOMAIN(Compare, DomainT);

   Comparison functor for domain values.

3.     template<typename SubType>
         void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);

   Assignment from a base `interval_set`.

### `separate_interval_set` private member functions

1.     iterator handle_inserted(iterator inserted_);

2.     iterator add_over(const interval_type & addend, iterator last_);

3.     iterator add_over(const interval_type & addend);