[/
    Copyright (c) 2008-2009 Joachim Faulhaber

    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
]


[/ //= Construct, copy, destruct ===================================================================]
[section Construct, copy, destruct]

[table
[[['*Construct, copy, destruct*]]      [__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__] ]
[[`T::T()`]                                    [1]       [1]      [1]     [1]      [1]   ]
[[`T::T(const P&)`]                            [A]   [__eiS]  [__bpM]     [1]      [1]   ]
[[`T& T::operator=(const P&)`]                 [A]     [__S]    [__M]     [1]      [1]   ]
[[`void T::swap(T&)`]                          [ ]       [1]      [1]     [1]      [1]   ]
]

All *icl* types are ['*regular types*]. They are ['*default constructible*], 
['*copy constructible*] and ['*assignable*]. On icl Sets and Maps a `swap`
function is available, that allows for *constant time* swapping of 
container contents.
The /regular and swappable part/ of the basic functions and their complexities
are described in the tables below. 

[table
[[['*Regular and swap*]]      [__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__] ]
[[`T::T()`]                                 [__O1__]  [__O1__] [__O1__][__O1__] [__O1__] ]
[[`T::T(const T&)`]                         [__O1__]  [__On__] [__On__][__On__] [__On__] ]
[[`T& T::operator=(const T&)`]              [__O1__]  [__On__] [__On__][__On__] [__On__] ]
[[`void T::swap(T&)`]                          [ ]    [__O1__] [__O1__][__O1__] [__O1__] ]
]

where /n/ `= iterative_size(x)`.

[table
[[['*Construct, copy, destruct*]] [Description] ]
[[`T::T()`]                       [Object of type T is default constructed.] ]
[[`T::T(const T& src)`]           [Object of type T is copy constructed from object `src`. ] ]
[[`T& T::operator=(const T& src)`][Assigns the contents of src to `*this` object. Returns a reference to the assigned object.] ]
[[`void T::swap(T& src)`]         [Swaps the content containers `*this` and `src` in constant time. ] ]
]

In addition we have overloads of constructors and assignment operators
for icl container types.
``
// overload tables for constructors
T::T(const P& src)

element containers:     interval containers:  
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    
``

For an object `dst` of type `T` and an argument `src` of type `P` let
``
n = iterative_size(dst);
m = iterative_size(src);
``
in the following tables.

[table Time Complexity for overloaded constructors on element containers
[[`T(const P& src)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
[[__icl_set__]      [__Olgn__]    []               [__Om__]         []               ]
[[__icl_map__]      []            [__Olgn__]       []               [__Om__]         ]
]

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

[table Time Complexity for overloaded constructors on interval containers
[[`T(const P& src)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
[[interval_sets]     [__O1__] [__O1__][]      []      [__Om__]    []          ]
[[interval_maps]     []       []      [__O1__][__O1__][]          [__Om__]    ]
]

``
// overload tables for assignment
T& operator = (const P& src)

interval containers:  
T \ P | S M    
------+----    
S     | S       
M     |   M    
``

The assignment `T& operator = (const P& src)` is overloaded within interval containers.
For all type combinations we have ['*linear time complexity*]
in the maximum of the `iterative_size` of `dst` and `src`.


['*Back to section . . .*]
[table
[]
[[[link function_synopsis_table ['*Function Synopsis*]]]]
[[[link boost_icl.interface ['*Interface*]]                          ]]
]


[endsect][/ Construct, copy, destruct]


