Insertion

Synopsis

Insertion	interval sets	interval maps	element sets	element maps
`V T::insert(const P&)`	e i	b p	e	b
`V insert(T&, const P&)`	e i	b p	e	b
`J T::insert(J pos, const P&)`	i	p	e	b
`J insert(T&, J pos, const P&)`	i	p	e	b
`T& insert(T&, const P&)`	e i S	b p M	e s	b m
`T& T::set(const P&)`		b p		1
`T& set_at(T&, const P&)`		b p		1

Insertion

The effects of insertion implemented by insert and addition implemented by add and operator += are identical for all Set-types of the icl.

For Map-types, insert provides the stl semantics of insertion in contrast to add and operator +=, that implement a generalized addition, that performs aggregations if key values collide or key intervals overlap. insert on Maps does not alter a maps content at the points, where the keys of the object to inserted overlap or collide with keys that are already in the map.

Setting values

Overwriting values using operator[] like in

my_map[key] = new_value;

is not provided for interval_maps because an operator[] is not implemented for them. As a substitute a function T& T::set(const P&) can be used to achieve the same effect:

my_map.set(make_pair(overwrite_this, new_value));

Insertion

// overload table for functions      T\P| e i b p  
V T::insert(const P&)                ---+--------
V insert(T&, const P&)                s | s
                                      m |     m
                                      S |   S
                                      M |       M

Table 1.27. Time Complexity for member function insert on icl containers

`T& T::insert(const P&)`	domain type	interval type	domain mapping type	interval mapping type
`std::set`	O(log n)
`icl::map`			O(log n)
`interval_set` `separate_interval_set`	O(log n)	amortized O(log n)
`split_interval_set`	O(log n)	O(n)
`interval_map` `split_interval_map`			O(log n)	O(n)

// overload tables for function      element containers:     interval containers:  
T& insert(T&, const P&)              T\P| e b s m            T\P| e i b p S M
                                     ---+--------            ---+------------
                                      s | s   s               S | S S     S
                                      m |   m   m             M |     M M   M

Table 1.28. Time Complexity for inplace insertion on element containers

`T& insert(T& y, const P& x)`	domain type	domain mapping type	interval sets	interval maps
`std::set`	O(log n)		O(m)
`icl::map`		O(log n)		O(m)

Time complexity characteristics of inplace insertion for interval containers is given by this table.

Table 1.29. Time Complexity for inplace insertion on interval containers

`T& insert(T& y, const P& x)`		domain type	interval type	domain mapping type	interval mapping type	interval sets	interval maps
interval_sets	`interval_set` `separate_interval_set`	O(log n)	amortized O(log n)			O(m log(n+m))
	`split_interval_set`	O(log n)	O(n)			O(m log(n+m))
interval_maps				O(log n)	O(n)		O(m log(n+m))

Hinted insertion

Function J T::insert(J prior, const P& addend) allows for an insertion in constant time, if addend can be inserted right after iterator prior without collision. If this is not possible the complexity characteristics are as stated for the non hinted insertion above. Hinted insertion is available for these combinations of types:

// overload table for insertion with hint        T\P| e i b p  
J T::insert(J pos, const P&)                     ---+--------
J insert(T&, J pos, const P&)                     s | s
                                                  m |     m
                                                  S |   S
                                                  M |       M

Setting values

// overload table for member function         T\P| b p 
T& T::set(const P&)                           ---+----
T& set_at(T&, const P&)                        m | m
                                               M |   M

Table 1.30. Time Complexity for member function `set`

`T& set(T&, const P&)`	domain_mapping_type	interval_mapping_type
icl::map	O(log n)
interval_maps		amortized O(log n)