108 lines
4.0 KiB
Plaintext
108 lines
4.0 KiB
Plaintext
[/
|
|
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]
|
|
|
|
|