[Boost-commit] svn:boost r66069 - sandbox/itl/libs/itl/doc

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