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

Subject: [Boost-commit] svn:boost r65980 - sandbox/itl/libs/itl/doc
From: afojgo_at_[hidden]
Date: 2010-10-15 09:58:26

Author: jofaber
Date: 2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
New Revision: 65980
URL: http://svn.boost.org/trac/boost/changeset/65980

Log:
Updated documentation. Replaced qbk-macros __itl_* by __icl_*. 
Text files modified: 
   sandbox/itl/libs/itl/doc/concepts.qbk                 |    14 +++++++-------                          
   sandbox/itl/libs/itl/doc/examples.qbk                 |     2 +-                                      
   sandbox/itl/libs/itl/doc/functions.qbk                |     2 +-                                      
   sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk |     4 ++--                                    
   sandbox/itl/libs/itl/doc/functions_containedness.qbk  |     8 ++++----                                
   sandbox/itl/libs/itl/doc/implementation.qbk           |     8 ++++----                                
   sandbox/itl/libs/itl/doc/interface.qbk                |    20 ++++++++++----------                    
   sandbox/itl/libs/itl/doc/introduction.qbk             |     8 ++++----                                
   sandbox/itl/libs/itl/doc/itl.qbk                      |    16 ++++++++++------                        
   sandbox/itl/libs/itl/doc/semantics.qbk                |     8 ++++----                                
   10 files changed, 47 insertions(+), 43 deletions(-)

Modified: sandbox/itl/libs/itl/doc/concepts.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/concepts.qbk	(original)
+++ sandbox/itl/libs/itl/doc/concepts.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -30,13 +30,13 @@
 [table
 []
 [[]                  [`Set`]                                        [`Map`]      ]
-[[element container] [__itl_set__]                                  [__itl_map__]]
+[[element container] [__icl_set__]                                  [__icl_map__]]
 [[interval container][__itv_set__, __sep_itv_set__, __spl_itv_set__][__itv_map__, __spl_itv_map__]]
 ]
 
-* Containers __itl_set__, __itv_set__, __sep_itv_set__, __spl_itv_set__
+* Containers __icl_set__, __itv_set__, __sep_itv_set__, __spl_itv_set__
   are models of concept `Set`. 
-* Containers __itl_map__, __itv_map__, __spl_itv_map__
+* Containers __icl_map__, __itv_map__, __spl_itv_map__
   are models of concept `Map`. 
 * Containers that are ['*implemented*] using elements or element value pairs
   are called ['*element containers*].
@@ -46,7 +46,7 @@
 * When we talk about /element containers/ or /interval containers/ 
   we refer to the way they are implemented.
 * The *itl's* element containers
-  are always denoted qualified as __itl_set__ of __itl_map__ 
+  are always denoted qualified as __icl_set__ of __icl_map__ 
   to avoid confusion with `std::set` and `std::map`. 
 
 [endsect][/ Naming]
@@ -94,7 +94,7 @@
 
 [h5 A Set Concept]
 
-On the __conceptual__ aspect the __itl_set__ and all __itv_bsets__ are models 
+On the __conceptual__ aspect the __icl_set__ and all __itv_bsets__ are models 
 of a concept `Set`.
 The `Set` concept of the Interval Template Library refers to the
 mathematical notion of a set.
@@ -116,7 +116,7 @@
 is used for the stronger lexicographical equality on segments, that takes the 
 segmentation of elements into account.
 
-Being models of concept `Set`, __itl_set__ and all __itv_bsets__ 
+Being models of concept `Set`, __icl_set__ and all __itv_bsets__ 
 implement these 
 operations and obey the associated laws on `Sets`. See e.g. 
 [@http://en.wikipedia.org/wiki/Algebra_of_sets an algebra of sets here].
@@ -140,7 +140,7 @@
 
 [h5 A Map Concept]
 
-On the __conceptual__ aspect __itl_map__ and all __itv_bmaps__ are models of a 
+On the __conceptual__ aspect __icl_map__ and all __itv_bmaps__ are models of a 
 concept `Map`.
 Since a `map` is a `set of pairs`, we try to design the `Map` concept in accordance
 to the `Set` concept above. 

Modified: sandbox/itl/libs/itl/doc/examples.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/examples.qbk	(original)
+++ sandbox/itl/libs/itl/doc/examples.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -56,7 +56,7 @@
             [__itv_map__,\n__sep_itv_set__][Fill interval containers from user defined objects using `std::transform`.]]
             
         [[customize] [[link boost_icl.examples.custom_interval Custom interval]]
-	    [JODO interval_traits][Use interval containers with your own interval class types.]]
+	    [__itv_tr__][Use interval containers with your own interval class types.]]
 
 ]
 

Modified: sandbox/itl/libs/itl/doc/functions.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions.qbk	(original)
+++ sandbox/itl/libs/itl/doc/functions.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -194,7 +194,7 @@
 [[__e: `domain_type`   ][  key value pair       ][   key value pair ]]
 [[__i: `interval_type` ][  interval value pair  ][					 ]]
 [[__S: __itv_sets__    ][  interval map		    ][					 ]]
-[[__s: __itl_set__     ][                       ][   interval map	 ]]
+[[__s: __icl_set__     ][                       ][   interval map	 ]]
 ]
 
 __biLSubtraction__, __biLerasure__, __biLintersection__

Modified: sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk	(original)
+++ sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -65,8 +65,8 @@
 
 [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__]]
-[[__itl_set__]    [__Olgn__]    []               [__Om__]         []               ]
-[[__itl_map__]    []            [__Olgn__]       []               [__Om__]         ]
+[[__icl_set__]    [__Olgn__]    []               [__Om__]         []               ]
+[[__icl_map__]    []            [__Olgn__]       []               [__Om__]         ]
 ]
 
 Time complexity characteristics of inplace insertion for interval containers

Modified: sandbox/itl/libs/itl/doc/functions_containedness.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_containedness.qbk	(original)
+++ sandbox/itl/libs/itl/doc/functions_containedness.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -69,8 +69,8 @@
   m     | 1   1           M     | 1 1     1      
 ``
 
-For type *m* = __itl_map__, 
-a key element (*m*`::domain_type`) and an __itl_set__ 
+For type *m* = __icl_map__, 
+a key element (*m*`::domain_type`) and an __icl_set__ 
 (*m*`::set_type`) can be a ['*key object*].
 
 For an interval map type *M*, 
@@ -88,8 +88,8 @@
 
 [table Time Complexity for function contains on element containers
 [[`bool T::contains(const P& sub)const`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
-[[__itl_set__]                          [__Olgn__]    []               [__Omlgn__]     []              ]
-[[__itl_map__]                          [__Olgn__]    [__Olgn__]       [__Omlgn__]     [__Omlgn__]     ]
+[[__icl_set__]                          [__Olgn__]    []               [__Omlgn__]     []              ]
+[[__icl_map__]                          [__Olgn__]    [__Olgn__]       [__Omlgn__]     [__Omlgn__]     ]
 ]
 
 

Modified: sandbox/itl/libs/itl/doc/implementation.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/implementation.qbk	(original)
+++ sandbox/itl/libs/itl/doc/implementation.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -27,10 +27,10 @@
 [*std::set] and [*std::map]. So the underlying data structure of
 interval containers is a red black tree of intervals or
 interval value pairs. 
-The element containers __itl_set__ and __itl_map__ are wrapper
+The element containers __icl_set__ and __icl_map__ are wrapper
 classes of `std::set` and `std::map`.
-Interval containers are then using __itl_sets__ of intervals
-or __itl_maps__ of interval value pairs as implementing
+Interval containers are then using __icl_sets__ of intervals
+or __icl_maps__ of interval value pairs as implementing
 containers.
 So all the ['*complexity characteristics*] of itl containers
 are based on and limited by the ['*red-black tree implementation*]
@@ -78,7 +78,7 @@
 
 [h4 Complexity of element containers]
 
-Since ['element containers] __itl_set__ and __itl_map__ are only extensions of
+Since ['element containers] __icl_set__ and __icl_map__ are only extensions of
 stl::set and stl::map, their complexity characteristics are
 accordingly. So their major operations insertion (addition),
 deletion and search are all using logarithmic time. 

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-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -32,7 +32,7 @@
 [[__itv_bsets__][__itv_set__]    [`<DomainT,Compare,Interval,Alloc>`]]
 [[]             [__sep_itv_set__][`<DomainT,Compare,Interval,Alloc>`]]
 [[]             [__spl_itv_set__][`<DomainT,Compare,Interval,Alloc>`]]
-[[__itl_set__]  [__itl_set__]    [`<DomainT,Compare,         Alloc>`]]
+[[__icl_set__]  [__icl_set__]    [`<DomainT,Compare,         Alloc>`]]
 [[=std::set=]   [`std::set`]     [`<_Key,  _Compare,        _Alloc>`]]
 ]
 
@@ -47,7 +47,7 @@
 [[template parameter] [`class`]  [`template <class>class`]     [`template <class, template<class>class> class`][`template <class>class`]]    
 [[__itv__]            [`DomainT`][`Compare = std::less`]       []                                              []]
 [[__itv_bsets__]      [`DomainT`][`Compare = std::less`]       [`Interval = itl::interval`]                    [`Alloc = std::alloc`]]
-[[__itl_set__]        [`DomainT`][`Compare = std::less`]       []                                              [`Alloc = std::alloc`]]
+[[__icl_set__]        [`DomainT`][`Compare = std::less`]       []                                              [`Alloc = std::alloc`]]
 [[template parameter] [`class`]  [`class`]                     [`class`]                                       [class]]
 [[=std::set=]         [`_Key`]   [`_Compare = std::less<_Key>`][]                                              [`Alloc = std::alloc<_Key>`]]
 ]
@@ -63,7 +63,7 @@
 [[group]        [template]       [instance parameters]]
 [[__itv_bmaps__][__itv_map__]    [`<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>`]]
 [[]             [__spl_itv_map__][`<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>`]]
-[[__itl_map__]  [__itl_map__]    [`<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>`]]
+[[__icl_map__]  [__icl_map__]    [`<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>`]]
 [[=std::map=]   [`std::map`]     [`<_Key,   _Data,          _Compare,               _Alloc>`]]
 ]
 
@@ -78,7 +78,7 @@
 [[]                   [elements][mapped values][traits]                      [order of elements]           [aggregation propagation]  [intersection propagation]     [type of intervals]                             [memory allocation]]
 [[template parameter] [`class`]  [`class`]     [`class`]                     [`template <class>class`]     [`template <class>class`]  [`template <class>class`]      [`template <class, template<class>class> class`][`template <class>class`]]    
 [[__itv_bmaps__]      [`DomainT`][`CodomainT`] [`Traits = neutron_absorber`] [`Compare = std::less`]       [`Combine = inplace_plus`] [`Section = itl::inplace_et`]  [`Interval = itl::interval`]                    [`Alloc = std::alloc`]]
-[[__itl_map__]        [`DomainT`][`CodomainT`] [`Traits = neutron_absorber`] [`Compare = std::less`]       [`Combine = inplace_plus`] [`Section = itl::inplace_et`]  [`Alloc = std::alloc`]]
+[[__icl_map__]        [`DomainT`][`CodomainT`] [`Traits = neutron_absorber`] [`Compare = std::less`]       [`Combine = inplace_plus`] [`Section = itl::inplace_et`]  [`Alloc = std::alloc`]]
 [[template parameter] [`class`]  [`class`]     []                            [`class`]                     []                         []                             []                                              [`class`]]
 [[=std::map=]         [`_Key`]   [`_Data`]     []                            [`_Compare = std::less<_Key>`][]                         []                             []                                              [`Alloc = std::alloc<_Key>`]]
 ]
@@ -217,7 +217,7 @@
 integral type. This seems like being trivial but there are types like e.g.
 `boost::date_time::ptime`, that are integral in nature but do
 not provide the required in- and decrementation on the least incrementable unit.
-For __itl_itvs__ incementation and decementation is used
+For __icl_itvs__ incementation and decementation is used
 for computations between open to closed interval borders like e.g.
 `[2,43) == [2,42]`. Such computations always need only
 one in- or decrementation, if `DomainT` is an integral type. 
@@ -256,7 +256,7 @@
 [[]           [`Section` used and `CodomainT` is a set][`&=`]             [`&& Intersectable<CodomainT,Section>`] ] 
 ]
 
-The requirements on the type `CodomainT` of associated values for a __itl_map__ or __itv_map__
+The requirements on the type `CodomainT` of associated values for a __icl_map__ or __itv_map__
 depend on the usage of their aggregation functionality. If aggregation on overlap
 is never used, that is to say that none of the addition, subtraction and intersection
 operations (`+, +=, add`, `-, -=, subtract`, &, &=, add_intersection) are used on the 
@@ -414,13 +414,13 @@
 [[`V`                         ] []                        [various types `V`, that do dot fall in the categories above]]             
 [[1,2,...                     ] []                        [number of implementations for this function]]             
 [[A                           ] []                        [implementation generated by compilers]]             
-[[[#element_type]         [*e]] [T::element_type]         [the element type of __itv_sets__ or __itl_sets__]]
+[[[#element_type]         [*e]] [T::element_type]         [the element type of __itv_sets__ or __icl_sets__]]
 [[[#interval_type]        [*i]] [T::segment_type]         [the segment type of of __itv_sets__]]
-[[[#itl_set_type]         [*s]] [__itl_set__]             [itl's set type]]
+[[[#itl_set_type]         [*s]] [__icl_set__]             [itl's set type]]
 [[[#interval_set_types]   [*S]] [interval_sets]           [one of the interval set types]]
-[[[#element_mapping_type] [*b]] [T::element_type]         [type of __itv_map_s__ or __itl_map_s__ element value pairs]]
+[[[#element_mapping_type] [*b]] [T::element_type]         [type of __itv_map_s__ or __icl_map_s__ element value pairs]]
 [[[#interval_mapping_type][*p]] [T::segment_type]         [type of __itv_map_s__ interval value pairs]]
-[[[#itl_map_type]         [*m]] [__itl_map__]             [itl's map type]]
+[[[#itl_map_type]         [*m]] [__icl_map__]             [itl's map type]]
 [[[#interval_map_types]   [*M]] [interval_maps]           [one of the interval map types]]
 ]
 

Modified: sandbox/itl/libs/itl/doc/introduction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/introduction.qbk	(original)
+++ sandbox/itl/libs/itl/doc/introduction.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -171,12 +171,12 @@
 [section Icl's class templates]
 
 In addition to interval containers the *itl* provides element containers
-__itl_set__ and __itl_map__. 
+__icl_set__ and __icl_map__. 
 
-* An __itl_set__ is behavioral equal to __itv_bsets__ on the __bi_conceptual__ aspect.
+* An __icl_set__ is behavioral equal to __itv_bsets__ on the __bi_conceptual__ aspect.
 
-* An __itl_map__ is behavioral equal to __itv_bmaps__ on the __bi_conceptual__  aspect. 
-  Specifically an __itl_map__
+* An __icl_map__ is behavioral equal to __itv_bmaps__ on the __bi_conceptual__  aspect. 
+  Specifically an __icl_map__
   implements ['*aggregate on overlap*], which is
   named ['*aggregate on collision*] for an element container.
 

Modified: sandbox/itl/libs/itl/doc/itl.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/itl.qbk	(original)
+++ sandbox/itl/libs/itl/doc/itl.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -20,8 +20,12 @@
 [/ Macros will be used for links so we have a central place to change them ]
 [def __itv__          [classref boost::icl::interval interval]]
 [def __Itv__          [classref boost::icl::interval Interval]]
+
+[def __itv_tr__       [classref boost::icl::interval interval_traits]]
+[def __Itv_tr__       [classref boost::icl::interval Interval_traits]]
+
 [def __itvs__         [classref boost::icl::interval intervals]]
-[def __itl_itvs__     [classref boost::icl::interval icl::intervals]]
+[def __icl_itvs__     [classref boost::icl::interval icl::intervals]]
 [def __Itvs__         [classref boost::icl::interval Intervals]]
 [def __itv_set__      [classref boost::icl::interval_set interval_set]]
 [def __itv_sets__     [classref boost::icl::interval_set interval_sets]]
@@ -33,8 +37,8 @@
 
 [def __ele_set__      [classref boost::icl::set set]]
 [def __ele_sets__     [classref boost::icl::set sets]]
-[def __itl_set__      [classref boost::icl::set icl::set]]
-[def __itl_sets__     [classref boost::icl::set icl::sets]]
+[def __icl_set__      [classref boost::icl::set icl::set]]
+[def __icl_sets__     [classref boost::icl::set icl::sets]]
 
 
 [def __Itv_set__      [classref boost::icl::interval_set Interval_set]]
@@ -83,9 +87,9 @@
 
 [def __ele_map__      [classref boost::icl::map map]]
 [def __ele_maps__     [classref boost::icl::map maps]]
-[def __itl_map__      [classref boost::icl::map icl::map]]
-[def __itl_maps__     [classref boost::icl::map icl::maps]]
-[def __itl_map_s__    [classref boost::icl::map icl::map's]]
+[def __icl_map__      [classref boost::icl::map icl::map]]
+[def __icl_maps__     [classref boost::icl::map icl::maps]]
+[def __icl_map_s__    [classref boost::icl::map icl::map's]]
 
 [def __pabsorber__     [classref boost::icl::partial_absorber partial_absorber]]
 [def __penricher__     [classref boost::icl::partial_enricher partial_enricher]]

Modified: sandbox/itl/libs/itl/doc/semantics.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/semantics.qbk	(original)
+++ sandbox/itl/libs/itl/doc/semantics.qbk	2010-10-15 09:58:22 EDT (Fri, 15 Oct 2010)
@@ -126,7 +126,7 @@
 [section Sets]
 
 For all set types `S` that are models concept `Set`  
-(__itl_set__, __itv_set__, __sep_itv_set__ and __spl_itv_set__)
+(__icl_set__, __itv_set__, __sep_itv_set__ and __spl_itv_set__)
 most of the well known mathematical 
 [@http://en.wikipedia.org/wiki/Algebra_of_sets laws on sets]
 were successfully checked via LaBatea. The next tables 
@@ -246,7 +246,7 @@
 separating  separate_interval_set
 splitting   split_interval_set
 ``
-where the __itl_set__ of elements can be subsumed in the `joining` rows.
+where the __icl_set__ of elements can be subsumed in the `joining` rows.
 
 
 Finally there are two laws that combine all three major set operations:
@@ -419,7 +419,7 @@
 The validity of the sets of laws that make up `Set` semantics
 should now be quite evident. So the following text shows the
 laws that are validated for all `Collector` types `C`. Which are
-__itl_map__`<D,S,T>`, __itv_map__`<D,S,T>` and __spl_itv_map__`<D,S,T>`
+__icl_map__`<D,S,T>`, __itv_map__`<D,S,T>` and __spl_itv_map__`<D,S,T>`
 where `CodomainT` type `S` is a model of `Set` and `Trait` type `T` is either 
 __pabsorber__ or __penricher__.
 
@@ -612,7 +612,7 @@
 
 Again, we are presenting the investigated sets of laws, this time for
 `Quantifier` types `Q` which are
-__itl_map__`<D,N,T>`, __itv_map__`<D,N,T>` and __spl_itv_map__`<D,N,T>`
+__icl_map__`<D,N,T>`, __itv_map__`<D,N,T>` and __spl_itv_map__`<D,N,T>`
 where `CodomainT` type `N` is a `Number` and `Trait` type `T` is one of
 the itl's map traits.