Subject: [Boost-commit] svn:boost r66069 - sandbox/itl/libs/itl/doc
From: afojgo_at_[hidden]
Date: 2010-10-18 06:03:02
Author: jofaber
Date: 2010-10-18 06:02:56 EDT (Mon, 18 Oct 2010)
New Revision: 66069
URL: http://svn.boost.org/trac/boost/changeset/66069
Log:
Updated documentation: Modified function references, erasure.
Text files modified:
sandbox/itl/libs/itl/doc/functions_addition.qbk | 86 +++++++++++++++++----------------------
sandbox/itl/libs/itl/doc/functions_erasure.qbk | 69 +++++++++++++------------------
sandbox/itl/libs/itl/doc/functions_insertion.qbk | 63 ++++++++++++-----------------
sandbox/itl/libs/itl/doc/functions_subtraction.qbk | 75 ++++++++++++++--------------------
sandbox/itl/libs/itl/doc/interface.qbk | 5 +
5 files changed, 127 insertions(+), 171 deletions(-)
Modified: sandbox/itl/libs/itl/doc/functions_addition.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_addition.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_addition.qbk 2010-10-18 06:02:56 EDT (Mon, 18 Oct 2010)
@@ -69,29 +69,27 @@
[endsect][/ Synopsis]
-[section Member functions][/ Addition]
+[section Functions][/ Addition]
The admissible combinations of types for member function
`T& T::add(const P&)` can be summarized in the
['*overload table*] below:
``
-// overload table for
-T& T::add(const P&)
-
-add | e i b p
-----+--------
-s | s
-m | m
-S | S S
-M | M M
+// overload table for T\P| e i b p
+T& T::add(const P&) ---+--------
+T& add(T&, const P&) s | s
+ m | m
+ S | S S
+ M | M M
``
The next table contains complexity characteristics for `add`.
[table Time Complexity for member function add on icl containers
-[[`T& T::add(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
-[/ [__icl_set__] [__Olgn__] [] [] [] ]
+[[`T& T::add(const P&)`\n
+ `T& add(T&, const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__icl_set__] [__Olgn__] [] [] [] ]
[[__icl_map__] [] [] [__Olgn__][] ]
[[__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] ]
[[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
@@ -106,18 +104,15 @@
the complexity characteristics are as stated for the non hinted addition
above. Hinted addition is available for these combinations of types:
``
-// overload table for addition with hint
-T& T::add(T::iterator prior, const P&)
-
-add | e i b p
-----+--------
-s | s
-m | m
-S | S
-M | M
+// overload table for addition with hint T\P| e i b p
+T& T::add(T::iterator prior, const P&) ---+--------
+T& add(T&, T::iterator prior, const P&) s | s
+ m | m
+ S | S
+ M | M
``
-[endsect][/ Member function Addition]
+[endsect][/ Functions Addition]
[section Inplace operators]
@@ -137,14 +132,11 @@
refers to /interval containers/.
``
-// overload tables for
-T& operator += (T&, const P&)
-
-element containers: interval containers:
-+= | e b s m += | e i b p S M
----+-------- ---+------------
-s | s s S | S S S
-m | m m M | M M M
+// overload tables for element containers: interval containers:
+T& operator += (T&, const P&) += | e b s m += | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m M | M M M
``
For the definition of admissible overloads
@@ -187,8 +179,8 @@
Sizes `n` and `m` are in the complexity statements are sizes
of objects `T y` and `P x`:
``
-n = y.iterative_size();
-m = x.iterative_size(); //if P is a container type
+n = iterative_size(y);
+m = iterative_size(x); //if P is a container type
``
Note, that for an interval container the number of elements `T::size` is
different from the number of intervals that you can iterate over.
@@ -229,22 +221,18 @@
are defined by the overload tables below.
``
-// overload tables for
-T operator + (T, const P&)
-T operator + (const P&, T)
-
-element containers: interval containers:
-+ | e b s m + | e i b p S1 S2 S3 M1 M3
----+-------- ---+---------------------------
-e | s e | S1 S2 S3
-b | m i | S1 S2 S3
-s | s s b | M1 M3
-m | m m p | M1 M3
- S1 | S1 S1 S1 S2 S3
- S2 | S2 S2 S2 S2 S3
- S3 | S3 S3 S3 S3 S3
- M1 | M1 M1 M1 M3
- M3 | M3 M3 M3 M3
+// overload tables for element containers: interval containers:
+T operator + (T, const P&) + | e b s m + | e i b p S1 S2 S3 M1 M3
+T operator + (const P&, T) ---+-------- ---+---------------------------
+ e | s e | S1 S2 S3
+ b | m i | S1 S2 S3
+ s | s s b | M1 M3
+ m | m m p | M1 M3
+ S1 | S1 S1 S1 S2 S3
+ S2 | S2 S2 S2 S2 S3
+ S3 | S3 S3 S3 S3 S3
+ M1 | M1 M1 M1 M3
+ M3 | M3 M3 M3 M3
``
[endsect][/ Infix operators]
@@ -261,7 +249,7 @@
[table
[]
[[[link function_synopsis_table ['*Function Synopsis*]] ]]
-[[[link boost_icl.interface ['*Interface*]] ]]
+[[[link boost_icl.interface ['*Interface*]] ]]
]
[endsect][/ Addition]
Modified: sandbox/itl/libs/itl/doc/functions_erasure.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_erasure.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_erasure.qbk 2010-10-18 06:02:56 EDT (Mon, 18 Oct 2010)
@@ -1,5 +1,5 @@
[/
- Copyright (c) 2008-2009 Joachim Faulhaber
+ Copyright (c) 2008-2010 Joachim Faulhaber
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
@@ -24,7 +24,7 @@
The effects of ['*erasure*] implemented by `erase` and ['*subtraction*]
implemented by `subtract` and `operator -=` are identical for all Set-types of
-the *itl*.
+the *icl*.
For Map-types, `erase` provides the *stl* semantics of erasure in
contrast to `subtract` and `operator -=`, that implement a generalized subtraction,
@@ -40,21 +40,19 @@
``
-// overload table for
-T& T::erase(const P&)
-
-erase | e i b p
-------+--------
- s | s
- m | m
- S | S S
- M | M M
+// overload table for T\P| e i b p
+T& T::erase(const P&) ---+--------
+T& erase(T&, const P&) s | s
+ m | m
+ S | S S
+ M | M M
``
-The next table contains complexity characteristics for member function `erase`.
-
-[table Time Complexity for member function erase on icl containers
-[[`T& T::erase(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+The next table contains complexity characteristics for the `erase` function on elements and segments.
+
+[table Time Complexity for erasure of elements and segments on icl containers
+[[`T& T::erase(const P&)`\n
+ `T& erase(T&, const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
[[__icl_set__] [__Olgn__] [] [] [] ]
[[__icl_map__] [__Olgn__] [] [__Olgn__] [] ]
[[__itv_sets__] [__Olgn__] [__a_Olgn__] [] [] ]
@@ -67,35 +65,26 @@
/insertion/.
``
-// overload tables for inplace function
-T& operator erase(T&, const P&)
-
-element containers: interval containers:
-erase | e b s m erase | e i b p S M
-------+-------- ------+------------
- s | s s S | S S S
- m | m m m m M | M M M M M M
+// overload tables for function element containers: interval containers:
+T& erase(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 M M M M M
``
-
We can split up these overloads in two groups.
The first group can be called /reverse insertion/.
-
``
-// (1) Reverse insertion
-erase | e b s m erase | e i b p S M
- ---+-------- ---+------------
- s | s s S | S S S
- m | m m M | M M M
+// (1) Reverse insertion 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
``
-
The second group can be viewed as an /erasure by key objects/
-
``
-// (2) Erasure by key objects
-erase | e b s m erase | e i b p S M
- ---+-------- ---+------------
- s | s s S | S S S
- m | m m M | M M M
+// (2) Erasure by key objects 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
``
On Maps ['*reverse insertion (1)*] is different from
@@ -111,8 +100,8 @@
Complexity characteristics for inplace erasure operations are
given by the next tables where
``
-n = y.iterative_size();
-m = x.iterative_size(); //if P is a container type
+n = iterative_size(y);
+m = iterative_size(x); //if P is a container type
``
[table Time Complexity for inplace erasure on element containers
@@ -132,7 +121,7 @@
[section Erasure by Iterators]
-The next table shows the *itl* containers that erasure with iterators is
+The next table shows the *icl* containers that erasure with iterators is
available for. Erase on iterators erases always one `value` of `value_type`
for an iterator pointing to it.
So we erase
Modified: sandbox/itl/libs/itl/doc/functions_insertion.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_insertion.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_insertion.qbk 2010-10-18 06:02:56 EDT (Mon, 18 Oct 2010)
@@ -21,6 +21,7 @@
[[`V insert(T&, J pos, const P&)`] [__i] [__p] [__e] [__b] ]
[[`T& insert(T&, const P&)`] [__eiS] [__bpM] [__es] [__bm] ]
[[`T& T::set(const P&)`] [ ] [__bp] [ ] [1] ]
+[[`T& set_at(T&, const P&)`] [ ] [__bp] [ ] [1] ]
]
@@ -28,7 +29,7 @@
The effects of ['*insertion*] implemented by `insert` and ['*addition*]
implemented by `add` and `operator +=` are identical for all Set-types of
-the *itl*.
+the *icl*.
For Map-types, `insert` provides the *stl* semantics of insertion in
contrast to `add` and `operator +=`, that implement a generalized addition,
@@ -56,15 +57,12 @@
[section Insertion]
``
-// overload table for member function
-T& T::insert(const P&)
-
-insert | e i b p
--------+--------
- s | s
- m | m
- S | S
- M | M
+// 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 Time Complexity for member function insert on icl containers
@@ -77,21 +75,18 @@
]
``
-// overload tables for function
-T& insert(T&, const P&)
-
-element containers: interval containers:
-insert | e b s m insert | e i b p S M
--------+-------- -------+------------
- s | s s S | S S S
- m | m m M | M M M
+// 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 Time Complexity for inplace insertion on element containers
[[`T& insert(T& y, const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
-[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
-[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
+[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
+[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
]
Time complexity characteristics of inplace insertion for interval containers
@@ -113,15 +108,12 @@
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& T::insert(T::iterator prior, const P&)
-
-insert | e i b p
--------+--------
-s | s
-m | m
-S | S
-M | M
+// overload table for insertion with hint T\P| e i b p
+V T::insert(J pos, const P&) ---+--------
+V insert(T&, J pos, const P&) s | s
+ m | m
+ S | S
+ M | M
``
[endsect][/ Insertion]
@@ -131,13 +123,10 @@
[section Setting values]
``
-// overload table for member function
-T& T::set(const P&)
-
-set | b p
-----+----
-m | m
-M | M
+// 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 Time Complexity for member function `set`
@@ -164,4 +153,4 @@
[endsect][/ Insertion]
-
+
Modified: sandbox/itl/libs/itl/doc/functions_subtraction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_subtraction.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_subtraction.qbk 2010-10-18 06:02:56 EDT (Mon, 18 Oct 2010)
@@ -45,34 +45,31 @@
]]
]
-
[endsect][/ Synopsis]
-[section Member functions][/ Subtraction]
+[section Functions][/ Subtraction]
-The admissible combinations of types for member function
-`T& T::add(const P&)` can be summarized in the
+The admissible combinations of types for subtraction functions
+can be summarized in the
['*overload table*] below:
``
-// overload table for
-T& T::subtract(const P&)
-
-subtract | e i b p
----------+--------
- s | s
- m | m
- S | S S
- M | M M
+// overload table for T\P| e i b p
+T& T::subtract(const P&) ---+--------
+T& subtract(T&, const P&) s | s
+ m | m
+ S | S S
+ M | M M
``
The next table contains complexity characteristics for `subtract`.
-[table Time Complexity for member function subtract on icl containers
-[[`T& T::subtract(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
-[/ [__icl_set__] [__Olgn__] [] [] [] ]
+[table Time Complexity for function subtract on icl containers
+[[`T& T::subtract(const P&)`\n
+ `T& subtract(T&, const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__icl_set__] [__Olgn__] [] [] [] ]
[[__icl_map__] [__Olgn__] [] [__Olgn__] [] ]
[[__itv_sets__] [__Olgn__] [__a_Olgn__] [] [] ]
[[__itv_maps__] [__Olgn__] [__On__] [__Olgn__] [__On__] ]
@@ -88,25 +85,21 @@
addition.
``
-// overload tables for
-T& operator -= (T&, const P&)
-
-element containers: interval containers:
--= | e b s m -= | e i b p S M
----+-------- ---+------------
-s | s s S | S S S
-m | m m m m M | M M M M M M
+// overload tables for element containers: interval containers:
+T& operator -= (T&, const P&) -= | e b s m -= | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m m m M | M M M M M M
``
Subtraction provides the /reverse/ operation
of an addition for these overloads,
``
-// Reverse addition
--= | e b s m -= | e i b p S M
----+-------- ---+------------
-s | s s S | S S S
-m | m m M | M M M
+// Reverse addition -= | e b s m -= | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m M | M M M
``
[*and] you can erase parts of __icl_maps__ or __itv_maps__
@@ -115,11 +108,10 @@
using these overloads:
``
-// Erasure by key objects
--= | e b s m -= | e i b p S M
----+-------- ---+------------
-s | s s S | S S S
-m | m m M | M M M
+// Erasure by key objects -= | e b s m -= | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m M | M M M
``
On Sets both function groups fall together
@@ -128,8 +120,8 @@
Complexity characteristics for inplace subtraction operations are
given by the next tables where
``
-n = y.iterative_size();
-m = x.iterative_size(); //if P is a container type
+n = iterative_size(y);
+m = iterative_size(x); //if P is a container type
``
[table Time Complexity for inplace Subtraction on element containers
@@ -157,13 +149,10 @@
is given by the next overload table.
``
-// overload tables for
-T operator - (T, const P&)
-
-- | e b s m - | e i b p S M
----+-------- ---+------------
-s | s s S | S S S
-m | m m m m M | M M M M M M
+// overload tables for - | e b s m - | e i b p S M
+T operator - (T, const P&) ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m m m M | M M M M M M
``
[endsect][/- Infix operator Subtraction]
Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2010-10-18 06:02:56 EDT (Mon, 18 Oct 2010)
@@ -458,8 +458,8 @@
[[`size_type size(const T&)`] [1] [1] [1] [1] [1] ]
[[`size_type cardinality(const T&)`] [1] [1] [1] [1] [1] ]
[[`difference_type length(const T&)`] [1] [1] [1] [ ] [ ] ]
-[[`size_type iterative_size(const T&)`] [ ] [1] [1] [1] [1] ]
-[[`size_type interval_count(const T&)`] [ ] [1] [1] [ ] [ ] ]
+[[`size_type iterative_size(const T&)`] [ ] [1] [1] [1] [1] ]
+[[`size_type interval_count(const T&)`] [ ] [1] [1] [ ] [ ] ]
[[__biLSelection__ ] [ ] [ ] [ ] [ ] [ ] ]
[[`J T::find(const domain_type&)`] [ ] [1] [1] [2] [2] ]
@@ -505,6 +505,7 @@
[[`V insert(T&, J pos, const P&)`] [ ] [__i] [__p] [__e] [__b] ]
[[`T& insert(T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] ]
[[`T& T::set(const P&)`] [ ] [ ] [__bp] [ ] [1] ]
+[[`T& set_at(T&, const P&)`] [ ] [ ] [__bp] [ ] [1] ]
[[__biLErasure__] [ ] [ ] [ ] [ ] [ ] ]
[[`void T::clear()`] [ ] [1] [1] [1] [1] ]