| [/ |
| 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] |
| |
| |