|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r49830 - in sandbox/itl: boost/itl libs/itl/doc libs/itl/example/boost_party
From: afojgo_at_[hidden]
Date: 2008-11-18 18:16:59
Author: jofaber
Date: 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
New Revision: 49830
URL: http://svn.boost.org/trac/boost/changeset/49830
Log:
Refactored: Introduced an access class to work with protected members of mixin classes.
Used solution of Alexander Nasonov (http://accu.org/index.php/journals/296).
Added itl.qbk and jamfile.v2. Began boost style documentation.
Stable {msvc-9.0}
Added:
sandbox/itl/libs/itl/doc/
sandbox/itl/libs/itl/doc/Jamfile.v2 (contents, props changed)
sandbox/itl/libs/itl/doc/itl.qbk (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/interval_base_map.hpp | 100 ++++++++++++++++++++++++++++++++-------
sandbox/itl/boost/itl/interval_base_set.hpp | 42 ++++++++++++++--
sandbox/itl/boost/itl/interval_map.hpp | 33 ------------
sandbox/itl/boost/itl/interval_set.hpp | 3
sandbox/itl/boost/itl/separate_interval_set.hpp | 7 +-
sandbox/itl/boost/itl/split_interval_map.hpp | 36 -------------
sandbox/itl/boost/itl/split_interval_set.hpp | 3
sandbox/itl/libs/itl/example/boost_party/boost_party.cpp | 4
8 files changed, 129 insertions(+), 99 deletions(-)
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -223,6 +223,63 @@
Traits,Compare,Alloc> atomized_type;
//@}
+private:
+ /** access is a technical class that makes protected members of derived classes
+ SubType accessible for direct call from the base class. Accessing via
+ fuction pointers has been proposed by Alexander Nasonov 2005:
+ http://accu.org/index.php/journals/296.
+ */
+ struct access : SubType
+ {
+ static bool contains(const SubType& subject, const typename SubType::value_type& operand)
+ {
+ bool (SubType::*fp)(const typename SubType::value_type&)const = &access::contains_;
+ return (subject.*fp)(operand);
+ }
+
+ template<class OperandT, class Combiner>
+ static void add(SubType& subject, const OperandT& operand, const Combiner& combine)
+ {
+ void (SubType::*fp)(const OperandT&, const Combiner&) = &access::add_;
+ (subject.*fp)(operand, combine);
+ }
+
+ template<class OperandT, class Combiner>
+ static void subtract(SubType& subject, const OperandT& operand, const Combiner& combine)
+ {
+ void (SubType::*fp)(const OperandT&, const Combiner&) = &access::subtract_;
+ (subject.*fp)(operand, combine);
+ }
+
+ template<class OperandT>
+ static void add(SubType& subject, const OperandT& operand)
+ {
+ void (SubType::*fp)(const OperandT&) = &access::add_;
+ (subject.*fp)(operand);
+ }
+
+ template<class OperandT>
+ static void subtract(SubType& subject, const OperandT& operand)
+ {
+ void (SubType::*fp)(const OperandT&) = &access::subtract_;
+ (subject.*fp)(operand);
+ }
+
+ template<class OperandT>
+ static void insert(SubType& subject, const OperandT& operand)
+ {
+ void (SubType::*fp)(const OperandT&) = &access::insert_;
+ (subject.*fp)(operand);
+ }
+
+ template<class OperandT>
+ static void erase(SubType& subject, const OperandT& operand)
+ {
+ void (SubType::*fp)(const OperandT&) = &access::erase_;
+ (subject.*fp)(operand);
+ }
+ };
+
public:
inline static bool has_symmetric_difference()
{ return is_set<codomain_type>::value || !traits::absorbs_neutrons || traits::emits_neutrons; }
@@ -270,11 +327,11 @@
//--- contains: map view ------------------------------------------------------
/// Does the map contain the element pair <tt>x = (key_element,value)</tt>?
bool contains(const base_pair_type& x)const
- { return that()->contains_(value_type(interval_type(x.key), x.data)); }
+ { return access::contains(*that(), value_type(interval_type(x.key), x.data)); }
/// Does the map contain all element value pairs represented by the interval-value pair sub?
bool contains(const value_type& sub)const
- { return that()->contains_(sub); }
+ { return access::contains(*that(), sub); }
/** Does <tt>*this</tt> container contain <tt>sub</tt>? */
bool contains(const interval_base_map& sub)const
@@ -331,7 +388,7 @@
template<class Combiner>
SubType& add(const base_pair_type& x, const Combiner& combine)
{
- that()->template add_(value_type(interval_type(x.KEY_VALUE), x.CONT_VALUE), combine);
+ access::add(*that(), value_type(interval_type(x.KEY_VALUE), x.CONT_VALUE), combine);
return *that();
}
@@ -351,17 +408,22 @@
If Combinator implements addition (+=) associated values will contain sums.
If Combinator implements max, associated values will contain maximal values and so on.
*/
+ //template<class Combiner>
+ //SubType& add(const value_type& x, const Combiner& combine)
+ //{ that()->add_(x, combine); return *that(); };
+
template<class Combiner>
- SubType& add(const value_type& x, const Combiner& combine)
- { that()->add_(x, combine); return *that(); };
+ SubType& add(const value_type& x, const Combiner& combine)
+ { access::add(*that(), x, combine); return *that(); }
+
template<class Combiner>
SubType& add(const value_type& x)
- { that()->add_(x, mpl::apply<Combiner,CodomainT>::type()); return *that(); };
+ { access::add(*that(), x, mpl::apply<Combiner,CodomainT>::type()); return *that(); };
template<template<class>class Combiner>
SubType& add(const value_type& x)
- { that()->add_(x, Combiner<CodomainT>()); return *that(); };
+ { access::add(*that(), x, Combiner<CodomainT>()); return *that(); };
/// Addition of a base value pair.
/** Addition of a base value pair <tt>x := pair(k,y)</tt> where <tt>base_value_type:=pair<DomainT,CodomainT></tt>
@@ -393,7 +455,7 @@
<tt>m0=m; m.add(x); m.subtract(x);</tt> implies <tt>m==m0 </tt>
*/
SubType& add(const value_type& x)
- { that()->add_(x, inplace_plus<CodomainT>()); return *that(); }
+ { access::add(*that(), x, inplace_plus<CodomainT>()); return *that(); }
//@}
@@ -449,7 +511,7 @@
*/
SubType& subtract(const base_pair_type& x)
{
- that()->subtract_( value_type(interval_type(x.key), x.data) );
+ access::subtract(*that(), value_type(interval_type(x.key), x.data) );
return *that();
}
@@ -470,9 +532,9 @@
SubType& subtract(const value_type& x)
{
if(Traits::emits_neutrons)
- that()->add_(x, inplace_minus<CodomainT>());
+ access::add(*that(), x, inplace_minus<CodomainT>());
else
- that()->subtract_(x, inplace_minus<CodomainT>());
+ access::subtract(*that(), x, inplace_minus<CodomainT>());
return *that();
}
@@ -493,7 +555,7 @@
*/
SubType& insert(const base_pair_type& x)
{
- that()->insert_( value_type(interval_type(x.key), x.data) );
+ access::insert(*that(), value_type(interval_type(x.key), x.data) );
return *that();
}
@@ -509,7 +571,7 @@
\c insert(x) is equivalent to \c add<inplace_identity>(x)
*/
SubType& insert(const value_type& x)
- { that()->insert_(x); return *that(); }
+ { access::insert(*that(), x); return *that(); }
/// Erase a base value pair from the map
/** Erase a base value pair <tt>x=(k,y)</tt>.
@@ -518,7 +580,7 @@
*/
SubType& erase(const base_pair_type& x)
{
- that()->erase_(value_type(interval_type(x.key), x.data));
+ access::erase(*that(), value_type(interval_type(x.key), x.data));
return *that();
}
@@ -532,7 +594,7 @@
\c erase(x) is equivalent to \c subtract<inplace_erasure>(x)
*/
SubType& erase(const value_type& x)
- { that()->erase_(x); return *that(); }
+ { access::erase(*that(), x); return *that(); }
/// Erase an associated value for a key
@@ -908,7 +970,7 @@
{
// x2 should be larger than *this; so every element in this should be in x2
const_FOR_IMPLMAP(it)
- if(!super.that()->contains_(*it))
+ if(!super.contains(*it))
return false;
return true;
}
@@ -1153,8 +1215,8 @@
victim = it; it++; _map.erase(victim);
}
- that()->add_(value_type(leftResid, leftResid_ContVal));
- that()->add_(value_type(rightResid, rightResid_ContVal));
+ add(value_type(leftResid, leftResid_ContVal));
+ add(value_type(rightResid, rightResid_ContVal));
return *that();
}
@@ -1170,7 +1232,7 @@
::erase(const interval_base_map& erasure)
{
const_FORALL(typename interval_base_map, value_pair_, erasure)
- that()->erase_(*value_pair_);
+ access::erase(*that(), *value_pair_);
return *that();
}
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -173,7 +173,35 @@
/// const_iterator for iteration over intervals
typedef typename ImplSetT::const_reverse_iterator const_reverse_iterator;
+private:
+ /** access is a technical class that makes protected members of derived classes
+ SubType accessible for direct call from the base class. Accessing via
+ fuction pointers has been proposed by Alexander Nasonov 2005:
+ http://accu.org/index.php/journals/296.
+ */
+ struct access : SubType
+ {
+ static bool contains(const SubType& subject, const typename SubType::value_type& operand)
+ {
+ bool (SubType::*fp)(const typename SubType::value_type&)const = &access::contains_;
+ return (subject.*fp)(operand);
+ }
+
+ static void add(SubType& subject, const typename SubType::value_type& operand)
+ {
+ void (SubType::*fp)(const typename SubType::value_type&) = &access::add_;
+ (subject.*fp)(operand);
+ }
+
+ static void subtract(SubType& subject, const typename SubType::value_type& operand)
+ {
+ void (SubType::*fp)(const typename SubType::value_type&) = &access::subtract_;
+ (subject.*fp)(operand);
+ }
+ };
+
+public:
// B: Constructors, destructors, assignment
/// Default constructor for the empty set
interval_base_set(){}
@@ -204,11 +232,11 @@
/// Does the container contain the element \c x
bool contains(const DomainT& x)const
- { return that()->contains_(interval_type(x)); }
+ { return access::contains(*that(), interval_type(x)); }
/// Does the container contain the interval x
bool contains(const interval_type& x)const
- { return that()->contains_(x); }
+ { return access::contains(*that(), x); }
/** Does <tt>*this</tt> container contain <tt>sub</tt>? */
bool contains(const interval_base_set& sub)const
@@ -251,11 +279,11 @@
/// Add a single element \c x to the set
SubType& add(const DomainT& x)
- { that()->add_(interval_type(x)); return *that(); }
+ { access::add(*that(), interval_type(x)); return *that(); }
/// Add an interval of elements \c x to the set
SubType& add(const value_type& x)
- { that()->add_(x); return *that(); }
+ { access::add(*that(), x); return *that(); }
//@}
@@ -265,11 +293,11 @@
/// Subtract a single element \c x from the set
SubType& subtract(const DomainT& x)
- { that()->subtract_(interval_type(x)); return *that(); }
+ { access::subtract(*that(), interval_type(x)); return *that(); }
/// Subtract an interval of elements \c x from the set
SubType& subtract(const value_type& x)
- { that()->subtract_(x); return *that(); }
+ { access::subtract(*that(), x); return *that(); }
///// Subtract a single element \c x from the set
//interval_base_set& operator -= (const DomainT& x)
@@ -502,7 +530,7 @@
{
// x2 should be larger than *this; so every element in this should be in x2
const_FOR_IMPL(it)
- if(!x2.that()->contains_(*it))
+ if(!x2.contains(*it))
return false;
return true;
}
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -174,9 +174,9 @@
this->add(*it);
}
+protected:
bool contains_(const value_type& x)const;
-
template<class Combiner>
void add_(const value_type&, const Combiner&);
@@ -197,9 +197,6 @@
void insert_(const value_type& value);
void erase_(const value_type& value);
- //TESTCODE
- void getResiduals(const interval_type& x_itv, interval_type& leftResid, interval_type& rightResid);
-
private:
bool insertable(const value_type& value)const
{
@@ -256,34 +253,6 @@
}
-template <typename DomainT, typename CodomainT, class Traits, template<class, template<class>class>class Interval, template<class>class Compare, template<class>class Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::getResiduals(const interval_type& x_itv, interval_type& leftResid, interval_type& rightResid)
-{
- iterator fst_it = this->_map.lower_bound(x_itv);
- iterator end_it = this->_map.upper_bound(x_itv);
-
- if(fst_it==end_it)
- {
- leftResid.clear();
- rightResid.clear();
- return;
- }
-
- (*fst_it).KEY_VALUE.left_surplus(leftResid, x_itv);
- iterator lst_it = fst_it; lst_it++;
-
- if(lst_it==end_it)
- {
- rightResid.clear();
- return;
- }
-
- lst_it=end_it; lst_it--;
-
- (*lst_it).KEY_VALUE.right_surplus(rightResid, x_itv);
-}
-
-
template <typename DomainT, typename CodomainT, class Traits,
template<class, template<class>class>class Interval, template<class>class Compare, template<class>class Alloc>
bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -203,6 +203,7 @@
this->add(*it);
}
+protected:
/// Does the set contain the interval <tt>x</tt>?
bool contains_(const interval_type& x)const;
@@ -212,10 +213,10 @@
/// Removal of an interval <tt>x</tt>
void subtract_(const value_type& x);
+private:
/// Treatment of adjoint intervals on insertion
void handle_neighbours(const iterator& it);
-protected:
iterator joint_insert(const iterator& left_it, const iterator& right_it);
} ;
Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -154,9 +154,6 @@
(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
{ assign(src); return *this; }
- /// Does the set contain the interval <tt>x</tt>?
- bool contains_(const interval_type& x)const;
-
/// Assignment from a base interval_set.
template<class SubType>
void assign(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
@@ -168,6 +165,9 @@
this->_set.insert(*it);
}
+protected:
+ /// Does the set contain the interval <tt>x</tt>?
+ bool contains_(const interval_type& x)const;
/// Insertion of an interval <tt>x</tt>
void add_(const value_type& x);
@@ -175,6 +175,7 @@
/// Removal of an interval <tt>x</tt>
void subtract_(const value_type& x);
+private:
/// Treatment of adjoint intervals on insertion
void handle_neighbours(const iterator& it){}
} ;
Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -188,9 +188,9 @@
this->_map.insert(*it);
}
+ protected:
bool contains_(const value_type& x)const;
-
template<class Combiner>
void add_(const value_type&, const Combiner&);
@@ -211,13 +211,9 @@
void insert_(const value_type& value);
void erase_(const value_type& value);
+ private:
void handle_neighbours(const iterator& it){}
- //TESTCODE
- void getResiduals(const interval_type& x_itv, interval_type& leftResid, interval_type& rightResid);
-
- private:
-
void fill(const value_type&);
template<class Combiner>
@@ -260,34 +256,6 @@
- template <typename DomainT, typename CodomainT, class Traits, template<class, template<class>class>class Interval, template<class>class Compare, template<class>class Alloc>
- void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::getResiduals(const interval_type& x_itv, interval_type& leftResid, interval_type& rightResid)
- {
- iterator fst_it = this->_map.lower_bound(x_itv);
- iterator end_it = this->_map.upper_bound(x_itv);
-
- if(fst_it==end_it)
- {
- leftResid.clear();
- rightResid.clear();
- return;
- }
-
- (*fst_it).KEY_VALUE.left_surplus(leftResid, x_itv);
- iterator lst_it = fst_it; lst_it++;
-
- if(lst_it==end_it)
- {
- rightResid.clear();
- return;
- }
-
- lst_it=end_it; lst_it--;
-
- (*lst_it).KEY_VALUE.right_surplus(rightResid, x_itv);
- }
-
-
template <typename DomainT, typename CodomainT, class Traits,
template<class, template<class>class>class Interval, template<class>class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -182,6 +182,7 @@
this->_set.insert(*it);
}
+ protected:
/// Does the set contain the interval <tt>x</tt>?
bool contains_(const interval_type& x)const;
@@ -191,10 +192,10 @@
/// Removal of an interval <tt>x</tt>
void subtract_(const value_type& x);
+ private:
/// Treatment of adjoint intervals on insertion
void handle_neighbours(const iterator& it){}
- private:
void insert_rest(const interval_type& x_itv, iterator& it, iterator& end_it);
void subtract_rest(const interval_type& x_itv, iterator& it, iterator& end_it);
} ;
Added: sandbox/itl/libs/itl/doc/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/Jamfile.v2 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -0,0 +1,55 @@
+# Boost.Itl
+#
+# Copyright (c) 2008-2008 Joachim Faulhaber
+# Copyright (c) 2000-2006 Cortex Software GmbH
+#
+# 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)
+
+import doxygen ;
+import quickbook ;
+
+# -----------------------------------------------------------------------------
+# Doxygen
+# -----------------------------------------------------------------------------
+
+doxygen itldoc
+ :
+ [ glob ../../../boost/itl/*.hpp ]
+ :
+ <doxygen:param>EXTRACT_ALL=YES
+ <doxygen:param>HIDE_UNDOC_MEMBERS=NO
+ <doxygen:param>EXTRACT_PRIVATE=NO
+ <doxygen:param>ENABLE_PREPROCESSING=YES
+ <doxygen:param>MACRO_EXPANSION=NO
+ <doxygen:param>EXPAND_ONLY_PREDEF=YES
+ <doxygen:param>SEARCH_INCLUDES=NO
+ <reftitle>"Interval Template Library DocTest"
+ ;
+
+
+# -----------------------------------------------------------------------------
+# Quickbook
+# -----------------------------------------------------------------------------
+
+import quickbook ;
+
+xml itl
+ :
+ itl.qbk
+ ;
+
+boostbook standalone
+ :
+ itl
+ :
+ <xsl:param>boost.root=../../../..
+ <xsl:param>boost.libraries=../../../libraries.htm
+ <xsl:param>toc.max.depth=2
+ <xsl:param>toc.section.depth=2
+ <xsl:param>chunk.section.depth=1
+ <dependency>itldoc
+
+ ;
+
Added: sandbox/itl/libs/itl/doc/itl.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/itl.qbk 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -0,0 +1,99 @@
+[library Boost.Itl
+ [quickbook 1.4]
+ [authors [Faulhaber, Joachim]]
+ [copyright 2007-2008 Joachim Faulhaber]
+ [copyright 2000-2006 Cortex Software GmbH]
+ [category container]
+ [id optional]
+ [dirname optional]
+ [purpose
+ Implements sets and maps as sets and maps of intervals
+ ]
+ [source-mode c++]
+ [license
+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])
+ ]
+]
+
+[/ Macros will be used for links so we have a central place to change them ]
+
+[/ Cited Boost resources ]
+
+[/ Other web resources ]
+
+[/ Icons ]
+
+[def __SPACE__ [$images/space.png]]
+[def __GO_TO__ [$images/callouts/R.png]]
+
+
+[section Introduction]
+
+The Interval Template Library (ITL) offers *intervals* and two kinds of
+interval containers: *interval_sets* and *interval_maps*.
+
+An [classref boost::itl::interval_base_set interval_set] implements a set as a set of intervals.[br]
+An [classref boost::itl::interval_base_map interval_map] implements a map as a map of interval value pairs.
+
+[classref boost::itl::interval_base_set Interval_sets] and
+[classref boost::itl::interval_base_map interval_maps] thus expose two different aspects in
+their interfaces: (1) The functionality of a set or a map, which is the more
+['abstract aspect]. And (2) the functionality of an interval container which
+is the more specific and ['implementation related aspect]. In practice both
+aspects are useful and are therefore supported.
+
+Working with interval_sets and interval_maps can be
+beneficial whenever in a given problem domain the elements of
+sets appear in contiguous chunks: intervals. This is obviously the
+case in many problem domains, namely in fields that deal with problems
+related to date and time.
+
+This is a first motivating example of a very small party, demonstrationg the
+['*aggregate on overlap*] principle ['*(aggrovering)*] on interval_maps:
+
+In the example Mary enters the party first. She attends during the
+time interval [20:00,22:00). Harry enters later he stays within [21:00,23:00).
+``
+typedef set<string> guests;
+interval_map<time, guests> party;
+party += make_pair(interval<time>::rightopen(20:00, 22:00), guests("Mary"));
+party += make_pair(interval<time>::rightopen(21:00, 23:00), guests("Harry"));
+// party now contains
+[20:00, 21:00)->{"Mary"}
+[21:00, 22:00)->{"Harry","Mary"} //guest sets aggregated on overlap
+[22:00, 23:00)->{"Harry"}
+``
+On overlap of intervals, the corresponding name sets ar accumulated. At
+the points of overlap the intervals are split. The accumulation of content on
+overlap of intervals is done via an operator += that has to be implemented
+for the content parameter of the interval_map.
+
+As can be seen from the example an interval_map has both
+a decompositional behavior (on the time dimension) as well as
+an accumulative one (on the associated values).
+
+[section Interval Container's Conduct]
+
+[table Synopsis over the behavior of interval containers
+ [[joining] [joining] [separating] [splitting]]
+ [[set] [R0-C2] [R0-C3] [R0-C4]]
+ [[map] [R1-C2] [R1-C3] [R1-C4]]
+]
+
+
+[endsect]
+
+[endsect]
+
+[/aggregate on overlap aggrovering]
+[/aggregate on collide aggrolliding]
+
+[include examples.qbk]
+[include dependencies.qbk]
+[include acknowledgments.qbk]
+[xinclude itldoc.xml]
+
+
+14:46 18.11.2008
\ No newline at end of file
Modified: sandbox/itl/libs/itl/example/boost_party/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party/boost_party.cpp 2008-11-18 18:16:58 EST (Tue, 18 Nov 2008)
@@ -139,7 +139,7 @@
BoostPartyAttendenceHistoryT::iterator it = party.begin();
- cout << "----- Histrory of party guests ------------------------\n";
+ cout << "----- History of party guests -------------------------\n";
while(it != party.end())
{
interval<ptime> when = (*it).first;
@@ -150,7 +150,7 @@
}
BoostPartyHeightHistoryT::iterator height_ = tallest_guest.begin();
- cout << "----- Histrory of maximum guest height ----------------\n";
+ cout << "----- History of maximum guest height -----------------\n";
while(height_ != tallest_guest.end())
{
interval<ptime> when = height_->first;
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk