[ceph.git] / ceph / src / boost / libs / icl / doc / functions_cons_copy_dest.qbk

[/
    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]
Commit	Line	Data
7c673cae FG	1	[/
	2	Copyright (c) 2008-2009 Joachim Faulhaber
	3
	4	Distributed under the Boost Software License, Version 1.0.
	5	(See accompanying file LICENSE_1_0.txt or copy at
	6	http://www.boost.org/LICENSE_1_0.txt)
	7	]
	8
	9
	10	[/ //= Construct, copy, destruct ===================================================================]
	11	[section Construct, copy, destruct]
	12
	13	[table
	14	[[['Construct, copy, destruct]] [__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__] ]
	15	[[`T::T()`] [1] [1] [1] [1] [1] ]
	16	[[`T::T(const P&)`] [A] [__eiS] [__bpM] [1] [1] ]
	17	[[`T& T::operator=(const P&)`] [A] [__S] [__M] [1] [1] ]
	18	[[`void T::swap(T&)`] [ ] [1] [1] [1] [1] ]
	19	]
	20
	21	All icl types are ['regular types]. They are ['default constructible],
	22	['copy constructible] and ['assignable]. On icl Sets and Maps a `swap`
	23	function is available, that allows for constant time swapping of
	24	container contents.
	25	The /regular and swappable part/ of the basic functions and their complexities
	26	are described in the tables below.
	27
	28	[table
	29	[[['Regular and swap]] [__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__] ]
	30	[[`T::T()`] [__O1__] [__O1__] [__O1__][__O1__] [__O1__] ]
	31	[[`T::T(const T&)`] [__O1__] [__On__] [__On__][__On__] [__On__] ]
	32	[[`T& T::operator=(const T&)`] [__O1__] [__On__] [__On__][__On__] [__On__] ]
	33	[[`void T::swap(T&)`] [ ] [__O1__] [__O1__][__O1__] [__O1__] ]
	34	]
	35
	36	where /n/ `= iterative_size(x)`.
	37
	38	[table
	39	[[['Construct, copy, destruct]] [Description] ]
	40	[[`T::T()`] [Object of type T is default constructed.] ]
	41	[[`T::T(const T& src)`] [Object of type T is copy constructed from object `src`. ] ]
	42	[[`T& T::operator=(const T& src)`][Assigns the contents of src to `*this` object. Returns a reference to the assigned object.] ]
	43	[[`void T::swap(T& src)`] [Swaps the content containers `*this` and `src` in constant time. ] ]
	44	]
	45
	46	In addition we have overloads of constructors and assignment operators
	47	for icl container types.
	48	``
	49	// overload tables for constructors
	50	T::T(const P& src)
	51
	52	element containers: interval containers:
	53	T \ P \| e b s m T \ P \| e i b p S M
	54	------+-------- ------+------------
	55	s \| s s S \| S S S
	56	m \| m m M \| M M M
	57	``
	58
	59	For an object `dst` of type `T` and an argument `src` of type `P` let
	60	``
	61	n = iterative_size(dst);
	62	m = iterative_size(src);
	63	``
	64	in the following tables.
65
66	[table Time Complexity for overloaded constructors on element containers
67	[[`T(const P& src)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
68	[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
69	[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
70	]
71
72	Time complexity characteristics of inplace insertion for interval containers
73	is given by this table.
74
75	[table Time Complexity for overloaded constructors on interval containers
76	[[`T(const P& src)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
77	[[interval_sets] [__O1__] [__O1__][] [] [__Om__] [] ]
78	[[interval_maps] [] [] [__O1__][__O1__][] [__Om__] ]
79	]
80
81	``
82	// overload tables for assignment
83	T& operator = (const P& src)
84
85	interval containers:
86	T \ P \| S M
87	------+----
88	S \| S
89	M \| M
90	``
91
92	The assignment `T& operator = (const P& src)` is overloaded within interval containers.
93	For all type combinations we have ['linear time complexity]
94	in the maximum of the `iterative_size` of `dst` and `src`.
95
96
97	['Back to section . . .]
98	[table
99	[]
100	[[[link function_synopsis_table ['Function Synopsis]]]]
101	[[[link boost_icl.interface ['Interface]] ]]
102	]
103
104
105	[endsect][/ Construct, copy, destruct]
106
107