Boost-Commit mailing page: [Boost-commit] svn:boost r54808 - in sandbox/cloneable/libs/cloneable/doc/html: . cloneable

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r54808 - in sandbox/cloneable/libs/cloneable/doc/html: . cloneable
From: christian.schladetsch_at_[hidden]
Date: 2009-07-08 16:10:31

Author: cschladetsch
Date: 2009-07-08 16:10:31 EDT (Wed, 08 Jul 2009)
New Revision: 54808
URL: http://svn.boost.org/trac/boost/changeset/54808

Log:
updated

Text files modified:
   sandbox/cloneable/libs/cloneable/doc/html/cloneable/heterogenous_containers.html | 431 +++++++++++++++++++++++
   sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial.html | 704 +++++++++++++++++++++++++++++++++++++++
   sandbox/cloneable/libs/cloneable/doc/html/index.html | 76 ++-
   sandbox/cloneable/libs/cloneable/doc/html/standalone_HTML.manifest | 17
   4 files changed, 1149 insertions(+), 79 deletions(-)

Modified: sandbox/cloneable/libs/cloneable/doc/html/cloneable/heterogenous_containers.html
==============================================================================
--- sandbox/cloneable/libs/cloneable/doc/html/cloneable/heterogenous_containers.html (original)
+++ sandbox/cloneable/libs/cloneable/doc/html/cloneable/heterogenous_containers.html 2009-07-08 16:10:31 EDT (Wed, 08 Jul 2009)
@@ -6,38 +6,37 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.1">
<link rel="home" href="../index.html" title="Cloneable 0.1">
<link rel="up" href="../index.html" title="Cloneable 0.1">
-<link rel="prev" href="tutorial/cloneable_traits.html" title="Cloneable Traits">
-<link rel="next" href="heterogenous_containers/extended_object_hierarhcy.html" title="Extended Object Hierarhcy">
+<link rel="prev" href="tutorial.html" title="Tutorial">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
<td align="center">People</td>
<td align="center">FAQ</td>
-<td align="center">More</td>
+<td align="center">More</td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tutorial/cloneable_traits.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="heterogenous_containers/extended_object_hierarhcy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
</div>
<div class="section" title="Heterogenous Containers">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="cloneable.heterogenous_containers"></a><a class="link" href="heterogenous_containers.html" title="Heterogenous Containers">Heterogenous Containers</a>
</h2></div></div></div>
<div class="toc"><dl>
-<dt><a href="heterogenous_containers/extended_object_hierarhcy.html">Extended
+<dt><a href="heterogenous_containers.html#cloneable.heterogenous_containers.extended_object_hierarhcy">Extended
 Object Hierarhcy</a></dt>
-<dt><a href="heterogenous_containers/container_method_names.html">Container
+<dt><a href="heterogenous_containers.html#cloneable.heterogenous_containers.container_method_names">Container
 Method Names</a></dt>
-<dt>List</dt>
-<dt>Vector</dt>
-<dt>Set</dt>
-<dt>Map</dt>
-<dt><a href="heterogenous_containers/heterogenous_map.html">Heterogenous
+<dt>List</dt>
+<dt>Vector</dt>
+<dt>Set</dt>
+<dt>Map</dt>
+<dt><a href="heterogenous_containers.html#cloneable.heterogenous_containers.heterogenous_map">Heterogenous
 Map</a></dt>
-<dt><a href="heterogenous_containers/hashmap_and_hashset.html">HashMap
+<dt><a href="heterogenous_containers.html#cloneable.heterogenous_containers.hashmap_and_hashset">HashMap
 and HashSet</a></dt>
</dl></div>

@@ -106,7 +105,7 @@
 
<div class="note" title="Note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/html/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top">
@@ -127,6 +126,404 @@
 which combines them. First, we shall extend our little Animal hierarchy to
 include an age member, and comparison operators.
 
+<div class="section" title="Extended Object Hierarhcy">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.extended_object_hierarhcy"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.extended_object_hierarhcy" title="Extended Object Hierarhcy">Extended
+ Object Hierarhcy</a>
+</h3></div></div></div>
+
+ This is the definitions we will use in the following examples. First, let's
+ look at a slightly extended base type for our Animal hierarchy:
+ 
+
+
+
+<pre class="programlisting">struct Animal
+{
+ double age;
+ string name;
+
+ Animal(double years_old = 0) : age(years_old) { }
+ Animal(string n, double years_old = 0) : age(years_old), name(n) { }
+
+ friend bool operator==(const Animal &left, const Animal &right) const
+ {
+ return left.age == right.age;
+ }
+ friend bool operator<(const Animal &left, const Animal &right) const
+ {
+ return left.age < right.age;
+ }
+ struct CompareNames
+ {
+ friend bool operator<(const Animal &left, const Animal &right) const
+ {
+ return left.name < right.name;
+ }
+ };
+};
+</pre>
+
+ 
+
+ This is just a little more elaborate than the previous example hierarchy
+ we used earlier in the tutorial. We have added an <code class="computeroutput">age</code>
+ field for all animals, indicating how old it is in years. Animals have relational
+ operators for testing equivalence and sorting. Another functor named <code class="computeroutput">CompareNames</code> is provided, which sorts by
+ the name field of animals rather than age.
+ 
+
+ You are aware that getting your base class right is very important to the
+ strength and efficacy of the hierarchy as a whole. At a minimum, you must
+ of course use a virtual destructor. Getting the comparison operators right
+ is very important as well, but of course we can always add more sorting predicates
+ such as <code class="computeroutput">CompareNames</code> as needed.
+ 
+
+ What we would like to avoid is having a so-called fat interface
+ as the base class, which has a lot of extra information that is only relevant
+ to one or more derived types. Some of these issues can be addressed with
+ further use of interfaces and virtual methods to obtain sorting criteria.
+ 
+
+ A full discussion on object-oriented design is beyond the scope of this brief
+ tutorial - and I'm sure you're very aware of the issues in any case. Suffice
+ to say that you should pay attention to how you design your base types. Always
+ use a virtual destructor, try to keep state to a minimum, and bear in mind
+ how you will want to compare objects.
+ 
+
+ Moving on, we define our derived types:
+ 
+
+
+
+<pre class="programlisting">struct Cat : cloneable::base<Cat, Animal>
+{
+ Cat(string name, double age = 10) : Animal(name, age) { }
+};
+
+struct Dog : cloneable::base<Dog, Animal>
+{
+ Dog(string name, double age = 0) : Animal(name, age) { }
+};
+
+struct Labrador : Dog, cloneable::base<Labrador, Animal>
+{
+ bool is_guide_dog;
+ Labrador(string name, bool can_lead, double age = 0) : Dog(name, age), is_guide_dog(can_lead) { }
+};
+</pre>
+
+ 
+
+ Labradors now have an extra field indicating that a given instance has been
+ trained as a guide dog, and each Animal type can be constructed by passing
+ its name and age. Note that there are no default constructors for any of
+ the Animal types.
+ 
+
+ Feel free to return to this page to refresh your memory as we walk through
+ some examples that use these definitions.
+ 
+
+ First, a preamble on names and semantics.
+ 
+</div>
+<div class="section" title="Container Method Names">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.container_method_names"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.container_method_names" title="Container Method Names">Container
+ Method Names</a>
+</h3></div></div></div>
+
+ To add an element of type <code class="computeroutput">Ty</code>
+ to any heterogenous container such as a <code class="computeroutput">list</code>,
+ <code class="computeroutput">vector</code> or <code class="computeroutput">set</code>
+ we use the following syntax:
+ 
+
+
+
+<pre class="programlisting">container.add_method_name<Ty>(a0, a1,..., an);
+</pre>
+
+ 
+
+ Specifically, we do not directly add an object to a heterogenous container.
+ Rather, we specify the type of thing to add, and provide any construction
+ arguments. This is true as well for specifying objects to search for in associative
+ containers:
+ 
+
+
+
+<pre class="programlisting">container.find<Ty>(a0, a1,..., an);
+</pre>
+
+ 
+
+ This creates a new object of type <code class="computeroutput">Ty</code>,
+ constructed with the provided arguments, searches for it in the container,
+ then destroys it. This means that you can store, and search for objects that
+ are not default constructable and/or do not have an assignment operator.
+ But, I'm getting a little ahead of ourselves here - more on associative containers
+ later.
+ 
+<div class="blockquote"><blockquote class="blockquote">
+
+ 
+
+ “Aside: The name for the method
+ to add new objects to heterogenous sequence containers has gone from
+ being called <code class="computeroutput">push_back</code>
+ to <code class="computeroutput">emplace_back</code> to <code class="computeroutput">push_emplace_back</code> and back to <code class="computeroutput">push_back</code>. Similarly for associative
+ containers the names have varied from <code class="computeroutput">insert</code>
+ to <code class="computeroutput">emplace</code> to <code class="computeroutput">emplace_insert</code> and back to <code class="computeroutput">insert</code>. The C++0x containers have emplace
+ methods that insert a new object after a given iterator location, by
+ passing construction arguments. These are called <code class="computeroutput">emplace</code>
+ methods. This is similar to the way that objects are added to heterogenous
+ containers, but not the same. For all heterogenous containers, the process
+ is to specify the type of thing and any creation arguments. There is
+ no need to specify an iterator, but there is a need to specify the type
+ explicitly. This is different to the C++0x containers, which do not require
+ the type. For this reason the names have changed and are yet to be settled.
+ All suggestions for the names of the methods, or namespaces, are welcome.
+ I am sure they'll end up being called something like <code class="computeroutput">emplace_back</code>
+ rather than <code class="computeroutput">push_back</code>;
+ but the difference is that there is no <code class="computeroutput">push_back</code>
+ in a heterogenous container: everything is always emplaced, so this is
+ one reason why I've been vacillating over the naming conventions to use”
+ 
+
+ 
+
+ -- CJS
+ 
+
+ 
+</blockquote></div>
+
+ With this in mind, let's visit the first container: the faithful list.
+ 
+</div>
+<div class="section" title="List">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.list"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.list" title="List">List</a>
+</h3></div></div></div>
+
+ The first heterogenous container we'll look at is the <code class="computeroutput">list</code>.
+ It is very much like a standard <code class="computeroutput">list<T></code>.
+ But it is also very different:
+ 
+
+
+
+<pre class="programlisting">typedef heterogenous::list<Animal> List;
+
+List list;
+list.push_back<Cat>("sam", 12);
+list.push_back<Dog>("spot", 8);
+list.push_back<Labrador>("max", 14);
+
+List copy = list;
+
+const Labrador &lab = list.back_as<Labrador>();
+assert(lab.name == "max" && lab.age == 14);
+</pre>
+
+ 
+
+ The first thing you may notice is the strange way we add new items to a list.
+ All heterogenous containers use emplace semantics for
+ searching for existing objects or adding new objects.
+ 
+
+ For now, it will be enough to absorb the emplacement syntax
+ for adding new elements, and to note that the cloned list called <code class="computeroutput">copy</code> made a deep copy of the list; the
+ underlying base pointers were not just copied - they were cloned.
+ 
+</div>
+<div class="section" title="Vector">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.vector"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.vector" title="Vector">Vector</a>
+</h3></div></div></div>
+
+ The vector gets the same treatment as lists, with the same syntax for adding
+ new elements, but also some extra methods for random access of specifically
+ typed contained objects:
+ 
+
+
+
+<pre class="programlisting">typedef heterogenous::vector<Animal> Vector;
+Vector vector;
+vector.push_back<Cat>("sam");
+vector.push_back<Dog>("spot");
+vector.push_back<Labrador>("max", 14);
+
+Vector copy = vector;
+
+Labrador &lab = vector.as<Labrador>(2);
+Dog &labs_dog = vector.as<Dog>(2);
+Dog &spot = vector.as<Dog>(1);
+
+const Dog *maybe_dog = vector.cast<Dog>(0);
+</pre>
+
+ 
+
+ <img src="../images/alert.png" alt="alert"> the names here have undergone a number of changes and
+ remain in flux. Suggestions welcome!
+ 
+
+ <code class="computeroutput">push_back</code> works just like
+ with <code class="computeroutput">list</code> and is not surprising.
+ But the <code class="computeroutput">as</code> and <code class="computeroutput">cast</code> methods are new.
+ 
+
+ <code class="computeroutput">vector::as</code> is the same as <code class="computeroutput">vector::at</code> except
+ that it requires a type to convert to. <code class="computeroutput">at</code>
+ will return a base reference. <code class="computeroutput">as</code>
+ returns a derived-type reference, or throws <code class="computeroutput">std::bad_cast</code>.
+ 
+
+ <code class="computeroutput">vector::cast</code> (another name in need of
+ a better name) returns a pointer of the given type to the specified
+ element, or returns the null pointer if conversion was not possible or ambiguous.
+ 
+
+ The other members in <code class="computeroutput">vector</code>
+ are largely what you would expect with no real surprises. See the reference
+ for complete details.
+ 
+</div>
+<div class="section" title="Set">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.set"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.set" title="Set">Set</a>
+</h3></div></div></div>
+
+ So far we have been intoduced to the two basic heterogenous sequence containers,
+ <code class="computeroutput">list</code> and <code class="computeroutput">vector</code>.
+ The main difference over the standard containers is how you add new objects
+ to them, and that they are, well, heterogenous. You can store any type of
+ object in them that derives from the base type that you used to define the
+ list or vector.
+ 
+
+ Things start to get interesting with the associative containers <code class="computeroutput">set</code> and <code class="computeroutput">map</code>.
+ Here we take a quick look at how we might use a heterogenous set to store
+ a collection of animals.
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef heterogenous::set<Animal> Set;
+ Set set;
+
+ const Cat &sam = set.emplace<Cat>("sam", 1.5).deref();
+ const Dog &spot = set.emplace<Dog>("spot", 3).deref();
+ const Labrador &max = set.emplace<Labrador>("max", 14).deref();
+
+ Set copy = set;
+
+ Set::iterator dog = copy.find<Dog>(14); // find a dog aged 14
+ Set::iterator any = copy.find<Animal>(1.5); // find any animal aged 1.5
+ Set::iterator cat = copy.find<Cat>(3); // find a cat aged 3
+
+ assert(&*dog == &max);
+ assert(&*any == &sam);
+ assert(cat == set.end());
+
+ return 0;
+}
+</pre>
+
+ 
+
+ TODO
+ 
+</div>
+<div class="section" title="Map">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.map"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.map" title="Map">Map</a>
+</h3></div></div></div>
+
+ TODO
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef map<int, Animal> Map;
+ Map map;
+ map.insert<Cat>(1, "sam", 6);
+ map.insert<Dog>(2, "spot", 6);
+ map.insert<Lab>(3, "max", 6);
+}
+</pre>
+
+ 
+
+ TODO
+ 
+</div>
+<div class="section" title="Heterogenous Map">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.heterogenous_map"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.heterogenous_map" title="Heterogenous Map">Heterogenous
+ Map</a>
+</h3></div></div></div>
+
+ And also a map of Cloneable to Cloneable:
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef heterogenous_map<Animal> Map;
+ Map map;
+ map.key<Dog>("spot", 12).value<Dog>("rover", 8);
+ map.key<Cat>("sam", 6).value<Cat>("sooty", 10);
+ map.key<Cat>("fluffy", 10).value<Cat>("tigger", 14);
+ map.key<Labrador>("max", 12).value<Cat>("sooty", 3);
+
+ // make a deep copy of both the keys and values in the map
+ Map copy = map;
+
+ // can search for any type of animal
+ assert(copy.find<Animal>("spot", 12) != copy.end());
+ assert(copy.find<Animal>("sam", 6) != copy.end());
+
+ // or, search for specific animal instances
+ assert(copy.find<Dog>("spot", 12) != copy.end());
+ assert(copy.find<Cat>("spot", 12) == copy.end());
+ assert(copy.find<Cat>("sam", 6) != copy.end());
+ assert(copy.find<Dog>("max", 12) != copy.end());
+ assert(copy.find<Dog>("fluffy", 10) == copy.end());
+
+ return 0;
+}
+</pre>
+
+ 
+
+ TODO
+ 
+</div>
+<div class="section" title="HashMap and HashSet">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.heterogenous_containers.hashmap_and_hashset"></a><a class="link" href="heterogenous_containers.html#cloneable.heterogenous_containers.hashmap_and_hashset" title="HashMap and HashSet">HashMap
+ and HashSet</a>
+</h3></div></div></div>
+
+ These share the same interface as <code class="computeroutput">map</code>
+ and <code class="computeroutput">set</code>, but are based on
+ hash tables rather than a tree.
+ 
+</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
@@ -138,7 +535,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tutorial/cloneable_traits.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="heterogenous_containers/extended_object_hierarhcy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
</div>
</body>
</html>

Modified: sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial.html
==============================================================================
--- sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial.html (original)
+++ sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial.html 2009-07-08 16:10:31 EDT (Wed, 08 Jul 2009)
@@ -6,41 +6,41 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.1">
<link rel="home" href="../index.html" title="Cloneable 0.1">
<link rel="up" href="../index.html" title="Cloneable 0.1">
-<link rel="prev" href="change_log.html" title="Change Log">
-<link rel="next" href="tutorial/simple_hierarchical_cloning.html" title="Simple Hierarchical Cloning">
+<link rel="prev" href="../index.html" title="Cloneable 0.1">
+<link rel="next" href="heterogenous_containers.html" title="Heterogenous Containers">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
<td align="center">People</td>
<td align="center">FAQ</td>
-<td align="center">More</td>
+<td align="center">More</td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="change_log.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial/simple_hierarchical_cloning.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="heterogenous_containers.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" title="Tutorial">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="cloneable.tutorial"></a><a class="link" href="tutorial.html" title="Tutorial"> Tutorial</a>
</h2></div></div></div>
<div class="toc"><dl>
-<dt><a href="tutorial/simple_hierarchical_cloning.html">Simple
+<dt><a href="tutorial.html#cloneable.tutorial.simple_hierarchical_cloning">Simple
 Hierarchical Cloning</a></dt>
-<dt><a href="tutorial/controlling_construction.html">Controlling
+<dt><a href="tutorial.html#cloneable.tutorial.controlling_construction">Controlling
 Construction</a></dt>
-<dt><a href="tutorial/using_external_types.html">Using External
+<dt><a href="tutorial.html#cloneable.tutorial.using_external_types">Using External
 Types</a></dt>
-<dt><a href="tutorial/dealing_with_muliple_sub_objects.html">Dealing
+<dt><a href="tutorial.html#cloneable.tutorial.dealing_with_muliple_sub_objects">Dealing
 with Muliple Sub-Objects</a></dt>
-<dt><a href="tutorial/customising_the_cloning_process.html">Customising
+<dt><a href="tutorial.html#cloneable.tutorial.customising_the_cloning_process">Customising
 the Cloning Process</a></dt>
-<dt><a href="tutorial/using_custom_allocators.html">Using Custom
+<dt><a href="tutorial.html#cloneable.tutorial.using_custom_allocators">Using Custom
 Allocators</a></dt>
-<dt>Cloneable Instance</dt>
-<dt>Cloneable Traits</dt>
+<dt>Cloneable Instance</dt>
+<dt>Cloneable Traits</dt>
</dl></div>

 This tutorial progresses through the basic usage of the library, demonstrating
@@ -129,7 +129,7 @@
 
<div class="note" title="Note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/html/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top">
@@ -148,6 +148,676 @@
 But we'll get to that later. For now, let's move on to some slightly less trivial
 examples.
 
+<div class="section" title="Simple Hierarchical Cloning">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.simple_hierarchical_cloning"></a><a class="link" href="tutorial.html#cloneable.tutorial.simple_hierarchical_cloning" title="Simple Hierarchical Cloning">Simple
+ Hierarchical Cloning</a>
+</h3></div></div></div>
+
+ In the previous example, we did not supply a base class, so our Cloneable
+ type was given the default <code class="computeroutput">base_type</code>.
+ Below, we prepare our own base type <code class="computeroutput">Animal</code>,
+ which of course has a virtual destructor, as well as a means to get a member
+ variable from a derived type:
+ 
+
+
+
+<pre class="programlisting">#include <string>
+#include <boost/cloneable.hpp>
+
+using namespace boost;
+using namespace std;
+
+class Animal
+{
+ virtual ~Animal() { }
+ virtual string get_name() const = 0;
+};
+</pre>
+
+ 
+
+ <code class="computeroutput">Animal</code> doesn't have to derive
+ from anything, or have any special members or methods.
+ 
+
+ Now let's use our base class to create a simple type hierarchy:
+ 
+
+
+
+<pre class="programlisting">class Cat : public cloneable::base<Cat, Animal>
+{
+ string name;
+
+public:
+ Cat() {}
+ Cat(string n) : name(n) { }
+ string get_name() const { return name; }
+};
+</pre>
+
+ 
+
+ We derive our <code class="computeroutput">Cat</code> class from
+ <code class="computeroutput">cloneable::base<Cat, Animal></code>. The first type argument to <code class="computeroutput">base<Cat, Animal></code> is the derived type to use for cloning,
+ and the second argument is the common base type of the hierarhcy. As we saw
+ in the first example, if you do not provide your own base type, your Cloneable
+ type will use the base <code class="computeroutput">cloneable::base_type</code>.
+ 
+
+ Other than that, <code class="computeroutput">Cat</code> implements
+ the <code class="computeroutput">get_name</code> pure virtual
+ method derived from the base class <code class="computeroutput">Animal</code>.
+ 
+
+ Now, let's use it:
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ Cat *cat = new Cat("sam");
+
+ // clone the cat. returns a pointer to the base class
+ Animal *animal = cat->clone();
+ assert(typeid(*animal) == typeid(Cat));
+
+ // downcast to our derived type
+ Cat *cloned = dynamic_cast<Cat *>(animal);
+ assert(cloned->get_name() == "sam");
+
+ return 0;
+};
+</pre>
+
+ 
+<div class="note" title="Note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ the <code class="computeroutput">clone()</code>
+ method returns a pointer to the base class of the type hierarchy - in this
+ case, <code class="computeroutput">Animal</code>.
+ </td></tr>
+</table></div>
+
+ We had to use a dynamic cast to down-cast to our derived type. If you know
+ the derived type that you wish to be cloned, you can use the <code class="computeroutput">clone_as<T>()</code>
+ method instead and save some typing:
+ 
+
+
+
+<pre class="programlisting">Cat *cloned = cat->clone_as<Cat>();
+</pre>
+
+ 
+
+ As we shall soon see, this is also handy when we have choices of which sub-object
+ to clone. Of course, we could also use the free-function <code class="computeroutput">clone</code>:
+ 
+
+
+
+<pre class="programlisting">using namespace cloneable;
+
+assert(can_clone_as<Cat>(*cat));
+Cat *cloned = clone(*cat);
+</pre>
+
+ 
+
+ We now add other animals to the hierachy, including one that uses multiple
+ inheritance:
+ 
+
+
+
+<pre class="programlisting">class Dog : public cloneable::base<Dog, Animal>
+{
+};
+
+class Labrador : public Dog, public cloneable::base<Labrador, Animal>
+{
+};
+</pre>
+
+ 
+
+ <code class="computeroutput">Dog</code> is just like a cat, but
+ different <img src="../images/smiley.png" alt="smiley">. <code class="computeroutput">Labrador</code>
+ is the first example we have seen that uses multiple inheritance. In this
+ case, we are saying that a Labrador is-a Dog, and is Cloneable as either
+ a Dog or a Labrador. Using these types:
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ Animal *lab = new Labrador();
+ Animal *lab_as_dog = lab->clone_as<Dog>();
+ Animal *lab_clone = lab->clone_as<Labrador>();
+
+ assert(typeid(*lab_as_dog) == typeid(Dog));
+ assert(typeid(*lab_clone) == typeid(Labrador));
+
+ assert(!can_clone_as<Labrador>(lab_as_dog));
+
+ return 0;
+}
+</pre>
+
+ 
+
+ When cloning the <code class="computeroutput">Labrador</code>
+ class, we must specify which sub-object we wish to duplicate using the <code class="computeroutput">clone_as<Ty></code>
+ method.
+ 
+
+ It should be noted that when using <code class="computeroutput">clone_as<Ty></code>, we actually are making an instance of
+ type <code class="computeroutput">Ty</code>, rather than making
+ another type and casting up.
+ 
+
+ We can also use the Cloneable library to make a new derived instance from
+ a base type:
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ Animal *cat = new Cat();
+ Animal *new_animal = create_new(*cat);
+
+ assert(typeid(*new_animal) == typeid(Cat));
+
+ return 0;
+}
+</pre>
+
+ 
+
+ This will create a new derived animal type (not a new base), and return a
+ pointer to the base.
+ 
+
+ This is the basics of the cloneability side of the library. But there are
+ a few more details and use-cases to cover before we get to the containers.
+ The first of these details is dealing with types that are not default-constructable.
+ This is a very useful part of the library, as it allows for containers with
+ elements that are not default constructable and do not have assignment operations.
+ We'll get to that in the containers tutorial, but for now let's quickly cover
+ the basics in the next section.
+ 
+</div>
+<div class="section" title="Controlling Construction">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.controlling_construction"></a><a class="link" href="tutorial.html#cloneable.tutorial.controlling_construction" title="Controlling Construction">Controlling
+ Construction</a>
+</h3></div></div></div>
+
+ We sometimes work with objects that cannot be default constructed. The Cloneable
+ system works with these types safely:
+ 
+
+
+
+<pre class="programlisting">struct Base { virtual ~Base() {} };
+
+struct T0 : cloneable::base<T0, Base, no_default_construction_tag>
+{
+ string &str;
+ T0(string &s) : str(s) { }
+};
+</pre>
+
+ 
+
+ <code class="computeroutput">T0</code> has a member that is a
+ reference and as such doesn't have a default constructor. To avoid compile-time
+ errors when using this type in the Cloneable libray, you must indicate that
+ it is not default-constructible by passing the <code class="computeroutput">no_default_construction_tag</code>
+ type as a parameter to <code class="computeroutput">cloneable::base<></code>. The order that you give the base-type
+ or tag-types to <code class="computeroutput">cloneable::base<></code> is not important.
+ 
+
+ Putting this type to use:
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ string str = "foo";
+ T0 *p = new T0(str);
+ T0 *q = clone(*p); // or, p->clone_as<T0>();
+ assert(&q->str == &str);
+
+ // demonstrate that attempting to create
+ // a new T0 instance without parameters
+ // results in an exception of type no_default_construction
+ bool caught = false;
+ try
+ {
+ p->create_new();
+ }
+ catch (no_default_construction)
+ {
+ caught = true;
+ }
+ assert(caught);
+ return 0;
+}
+</pre>
+
+ 
+
+ A <code class="computeroutput">no_default_construction</code>
+ exception is thrown if you attempt to default-construct a type that has no
+ default constructor. As you would expect, if a Cloneable Q type derives from
+ a non-default-constructable type, then Q is also not default-constructable.
+ 
+
+ Next, we'll look at how to use existing types that we can't change.
+ 
+</div>
+<div class="section" title="Using External Types">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.using_external_types"></a><a class="link" href="tutorial.html#cloneable.tutorial.using_external_types" title="Using External Types">Using External
+ Types</a>
+</h3></div></div></div>
+
+ Quite often we find ourselves using classes that are defined in an external
+ library. These are not open to be changed, but we would still like them to
+ be Cloneable. To address this issue, we can use the <code class="computeroutput">cloneable::adaptor<Type,Base></code>
+ structure:
+ 
+
+
+
+<pre class="programlisting">class External { /* hidden impl */ }; // for whatever reason, this cannot be modified
+
+class MyBase { virtual ~MyBase() { } };
+
+typedef cloneable::adaptor<External, MyBase> MyExternal;
+
+int main()
+{
+ MyExternal *ex = new MyExternal();
+ MyExternal *cloned = ex->clone_as<MyExternal>();
+ return 0;
+}
+</pre>
+
+ 
+
+ By using the <code class="computeroutput">cloneable::adaptor<Type, Base></code>
+ structure, we create a new type that is cloneable and can be used correctly
+ in heterogenous containers.
+ 
+
+ Alternatively of course, we could just make a new structure which either
+ derives from or encapsulates the external class. This will be necessary if
+ you wish to pass construction arguments to the external type, or provide
+ a custom clone method for it. For example:
+ 
+
+
+
+<pre class="programlisting">class Wrapper : cloneable::base<Wrapper, Base>
+{
+ External *impl;
+public:
+ Wrapper() : impl(0) { }
+ Wrapper(const Wrapper &other)
+ {
+ impl = new Wrapper(*other.impl);
+ }
+};
+</pre>
+
+ 
+
+ There are of course many ways to do this, and how you do it will depend on
+ many factors. Just bear in mind that <code class="computeroutput">cloneable::adaptor<></code> is there if you need it.
+ 
+
+ Next, we look at how to customise the cloning operation itself, and how we
+ can use our own or other allocators. This is important to understand before
+ we finally get to the heterogenous containers.
+ 
+</div>
+<div class="section" title="Dealing with Muliple Sub-Objects">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.dealing_with_muliple_sub_objects"></a><a class="link" href="tutorial.html#cloneable.tutorial.dealing_with_muliple_sub_objects" title="Dealing with Muliple Sub-Objects">Dealing
+ with Muliple Sub-Objects</a>
+</h3></div></div></div>
+
+ When working with types that have multiple cloneable sub-objects, we must
+ use the <code class="computeroutput">clone_as<T></code> and
+ <code class="computeroutput">create_as<T></code> methods
+ or functions to disambiguate which sub-type to clone or create.
+ 
+
+ This is demonstrated below:
+ 
+
+
+
+<pre class="programlisting">struct Base { virtual ~Base() { } };
+struct T0 : base<T0, Base> { };
+struct T1 : T0, base<T1, Base> { };
+struct W : base<W, Base> { };
+struct T2 : W, T1, base<T2, Base> { };
+
+int main()
+{
+ T2 *t2 = new T2();
+
+ assert(t2->can_clone_as<W>());
+ assert(t2->can_clone_as<T0>());
+ assert(t2->can_clone_as<T1>());
+ assert(t2->can_clone_as<T2>());
+
+ assert(t2->can_create_as<W>());
+ assert(t2->can_create_as<T0>());
+ assert(t2->can_create_as<T1>());
+ assert(t2->can_create_as<T2>());
+
+ // clone sub-objects
+ W *t2_w = t2->clone_as<W>();
+ T0 *t2_t0 = t2->clone_as<T0>();
+ T1 *t2_t1 = t2->clone_as<T1>();
+ T1 *t2_t2 = t2->clone_as<T2>();
+
+ // create sub-objects
+ W *t2_w_new = t2->create_as<W>();
+ T0 *t2_t0_new = t2->create_as<T0>();
+ T1 *t2_t1_new = t2->create_as<T1>();
+ T2 *t2_t2_new = t2->create_as<T2>();
+
+ return 0;
+}
+</pre>
+
+ 
+<div class="warning" title="Warning"><table border="0" summary="Warning">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/html/images/warning.png"></td>
+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top">
+ If a sub-type <code class="computeroutput">S</code> in type
+ <code class="computeroutput">T</code> is not default-constructabe,
+ an exception of type <code class="computeroutput">no_default_construction</code>
+ will be thrown if you attempt to default-create a new <code class="computeroutput">S</code>
+ instance from a <code class="computeroutput">T</code> instance.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" title="Customising the Cloning Process">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.customising_the_cloning_process"></a><a class="link" href="tutorial.html#cloneable.tutorial.customising_the_cloning_process" title="Customising the Cloning Process">Customising
+ the Cloning Process</a>
+</h3></div></div></div>
+
+ So far, we have been making clones using the default cloning process. This
+ uses the copy-constructor of a given type T to generate the clone. However,
+ quite often we will want to have greater control over this process, and sometimes
+ we don't want to or cannot use a copy constructor at all.
+ 
+
+ Customising the cloning process is a simple matter of providing a <code class="computeroutput">make_copy</code> method overload in your derived
+ class:
+ 
+
+
+
+<pre class="programlisting">class Foo : public cloneable::base<Foo>
+{
+ // over-ride the make_copy method, providing our own means to make a clone
+ Foo *make_copy() const
+ {
+ Foo *copy = new Foo();
+ // TODO: write values to copy from this
+ return copy;
+ }
+};
+</pre>
+
+ 
+
+ Please ensure that you override the <code class="computeroutput">make_copy() const</code> method
+ correctly. It must return a type that is co-variant with the base you used
+ for the derived type, and should be <code class="computeroutput">const</code>.
+ If you make a mistake on the return type, the compiler will complain. There
+ is a non-const <code class="computeroutput">make_copy()</code> method as well. This will be invoked on
+ a non-const original, then the const <code class="computeroutput">make_copy() const</code> will
+ be attempted before finally using the <code class="computeroutput">copy_construct() const</code> method.
+ To summarise:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ Attempting to make a copy of a non-const original will invoke <code class="computeroutput">make_copy()</code>
+</li>
+<li class="listitem">
+ If this fails or is not over-ridden, then the <code class="computeroutput">make_copy() const</code>
+ method is invoked.
+ </li>
+<li class="listitem">
+ If this fails is or not over-ridden, then <code class="computeroutput">copy_construct() const</code>
+ is invoked.
+ </li>
+</ul></div>
+
+ This provides a means for clones to be made that alter the original, if you
+ need to do that. For <code class="computeroutput">const</code> originals,
+ the process starts from step 2. All of these methods are over-loaded with
+ a similar method that takes an <code class="computeroutput">abstract_allocator</code>
+ argument.
+ 
+
+ Which is a nice segue into the next section. This example used the heap to
+ make clones; we will next see how to make clones using any standard-compliant
+ allocator type.
+ 
+</div>
+<div class="section" title="Using Custom Allocators">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.using_custom_allocators"></a><a class="link" href="tutorial.html#cloneable.tutorial.using_custom_allocators" title="Using Custom Allocators">Using Custom
+ Allocators</a>
+</h3></div></div></div>
+
+ The entire Cloneable system was designed to support general allocators. This
+ provides more fine-tuned control over cloning and creation operations, and
+ ensures Cloneable types work well in containers.
+ 
+
+ When making a new object, sub-object, clone or sub-clone, the underlying
+ <code class="computeroutput">abstract_base</code> is given a
+ reference to an <code class="computeroutput">abstract_allocator</code>.
+ This is an interface used to expose a specialised <code class="computeroutput">allocator<T></code>
+ to the non-specific <code class="computeroutput">abstract_base</code>.
+ This process is easy to understand with some examples:
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ std::allocator<int> alloc;
+ Cat *cat = cloneable::create<Cat>(alloc); // create a Cat using the allocator
+ Cat *dupe = cat->clone_as<Cat>(alloc); // clone using the same allocator
+
+ my_allocator<int> my_alloc;
+ Cat *dup2 = cat->clone_as<Cat>(my_alloc); // clone using another allocator
+ return 0;
+}
+</pre>
+
+ 
+
+ As you can see, most of the internals can be safely ignored. From this, it
+ becomes clear that if you write a clone override, you should do so for the
+ method that takes an <code class="computeroutput">abstract_allocator
+ &</code>, rather than just always use
+ the heap:
+ 
+
+
+
+<pre class="programlisting">class Foo : public cloneable::base<Foo>
+{
+ // over-ride the make_copy method, providing our own means to make a clone
+ Foo *make_copy(cloneable::abstract_allocator &alloc) const
+ {
+ Foo *copy = cloneable::create<Foo>(alloc);
+
+ // write values to copy from this; use alloc for any further required allocations
+
+ return copy;
+ }
+};
+</pre>
+
+ 
+
+ Recall that if your class can be correctly copy-constructed, you do not need
+ to provide a custom clone override at all. If your class only members that
+ have value semantics and can in turn be copy-constructed (including <code class="computeroutput">std::containers</code>,
+ and heterogenous::containers), then you do not need to provide any customisation.
+ So don't start by making a custom clone override method. First, check your
+ class to see if it is actually needed. Introducing a <code class="computeroutput">make_copy()</code> method too early or when not needed can
+ create maintenance problems.
+ 
+<div class="note" title="Note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ if your class contains pointers of any description, or references, then
+ you will in general have to at least provide a sensible copy-constructor,
+ or provide a custom clone override.
+ </td></tr>
+</table></div>
+
+ In summary, there are three stages of customisation:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ If your class has types with value semantics, the compiler-generated default
+ copy constructor will suffice.
+ </li>
+<li class="listitem">
+ If your class has types that need explicit construction, making a copy-constructor
+ for your class will suffice to make clones.
+ </li>
+<li class="listitem">
+ If your class has members that contain references, or require allocation,
+ then you should override <code class="computeroutput">make_copy</code>
+ and construct the members in the copy instance, using the supplied abstract_allocator.
+ </li>
+</ul></div>
+</div>
+<div class="section" title="Cloneable Instance">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.cloneable_instance"></a><a class="link" href="tutorial.html#cloneable.tutorial.cloneable_instance" title="Cloneable Instance">Cloneable Instance</a>
+</h3></div></div></div>
+
+ <img src="../images/alert.png" alt="alert"> subject to change -- CJS
+ 
+
+ A structure named <code class="computeroutput">instance<></code> is available within the library for
+ storing instances of cloneable objects.
+ 
+
+ This is used by the library to store a pointer to Cloneable objects, along
+ with the allocator that made it. It can be used, for example, to assign from
+ a generalised base to an <code class="computeroutput">instance<></code> without the user needing to manually
+ cast.
+ 
+
+
+
+<pre class="programlisting">struct Base { virtual ~Base() { } };
+
+struct Foo : cloneable::base<Foo, Base> { };
+
+void test()
+{
+ typedef cloneable::list<Base> List;
+ list.push_back<Foo>(1);
+ List::instance<Foo> foo = list.front();
+}
+</pre>
+
+ 
+
+ The full signature of this type is:
+ 
+
+
+
+<pre class="programlisting">template <
+ class Derived = any_derived_tag
+ , class Base = any_base_tag
+ , class Alloc = default_clone_allocator
+ , class Ctor = default_construction_tag
+ >
+struct instance;
+</pre>
+
+ 
+
+ But you will rarely need that when used as shown in the example.
+ 
+
+ The next section cleans up some housework required for library maintainers,
+ then we finally get to the fun stuff with the containers.
+ 
+</div>
+<div class="section" title="Cloneable Traits">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="cloneable.tutorial.cloneable_traits"></a><a class="link" href="tutorial.html#cloneable.tutorial.cloneable_traits" title="Cloneable Traits">Cloneable Traits</a>
+</h3></div></div></div>
+
+ This is mostly relevant to library maintainers and is not important otherwise.
+ 
+
+ To assist with dealing with cloneable objects in other systems, the following
+ traits are provided:
+ 
+
+
+
+<pre class="programlisting">class Base { virtual ~Base() { } };
+struct T : base<T, Base> { };
+struct U : base<T, Base, no_default_construction> { };
+struct V { };
+
+BOOST_STATIC_ASSERT(cloneable::is_cloneable<T>::value);
+BOOST_STATIC_ASSERT(cloneable::is_cloneable<U>::value);
+BOOST_STATIC_ASSERT(!cloneable::is_cloneable<V>::value);
+BOOST_STATIC_ASSERT(cloneable::has_base<T,Base>::value);
+
+//BOOST_STATIC_ASSERT(cloneable::is_default_constructable<V>::value); compile-time error: no traits
+BOOST_STATIC_ASSERT(cloneable::is_default_constructable<T>::value);
+BOOST_STATIC_ASSERT(!cloneable::is_default_constructable<T>::value);
+</pre>
+
+ 
+
+ Full details are in traits.hpp.
+ 
+</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
@@ -159,7 +829,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="change_log.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial/simple_hierarchical_cloning.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="heterogenous_containers.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/cloneable/libs/cloneable/doc/html/index.html
==============================================================================
--- sandbox/cloneable/libs/cloneable/doc/html/index.html (original)
+++ sandbox/cloneable/libs/cloneable/doc/html/index.html 2009-07-08 16:10:31 EDT (Wed, 08 Jul 2009)
@@ -5,19 +5,19 @@
<link rel="stylesheet" href="boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.1">
<link rel="home" href="index.html" title="Cloneable 0.1">
-<link rel="next" href="cloneable/change_log.html" title="Change Log">
+<link rel="next" href="cloneable/tutorial.html" title="Tutorial">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
<td align="center">People</td>
<td align="center">FAQ</td>
-<td align="center">More</td>
+<td align="center">More</td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="cloneable/change_log.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="cloneable/tutorial.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
<div class="article" title="Cloneable 0.1">
<div class="titlepage">
<div>
@@ -28,7 +28,7 @@
</h3></div></div></div>
<div>Copyright © 2009 Christian Schladetsch</div>
<div><div class="legalnotice" title="Legal Notice">
-<a name="id663289"></a>
+<a name="id649107"></a>
 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)
 
@@ -39,43 +39,43 @@
<div class="toc">
Table of Contents
<dl>
-<dt> Change Log</dt>
+<dt> Change Log</dt>
<dt> Tutorial</dt>
<dd><dl>
-<dt><a href="cloneable/tutorial/simple_hierarchical_cloning.html">Simple
+<dt><a href="cloneable/tutorial.html#cloneable.tutorial.simple_hierarchical_cloning">Simple
 Hierarchical Cloning</a></dt>
-<dt><a href="cloneable/tutorial/controlling_construction.html">Controlling
+<dt><a href="cloneable/tutorial.html#cloneable.tutorial.controlling_construction">Controlling
 Construction</a></dt>
-<dt><a href="cloneable/tutorial/using_external_types.html">Using External
+<dt><a href="cloneable/tutorial.html#cloneable.tutorial.using_external_types">Using External
 Types</a></dt>
-<dt><a href="cloneable/tutorial/dealing_with_muliple_sub_objects.html">Dealing
+<dt><a href="cloneable/tutorial.html#cloneable.tutorial.dealing_with_muliple_sub_objects">Dealing
 with Muliple Sub-Objects</a></dt>
-<dt><a href="cloneable/tutorial/customising_the_cloning_process.html">Customising
+<dt><a href="cloneable/tutorial.html#cloneable.tutorial.customising_the_cloning_process">Customising
 the Cloning Process</a></dt>
-<dt><a href="cloneable/tutorial/using_custom_allocators.html">Using Custom
+<dt><a href="cloneable/tutorial.html#cloneable.tutorial.using_custom_allocators">Using Custom
 Allocators</a></dt>
-<dt>Cloneable Instance</dt>
-<dt>Cloneable Traits</dt>
+<dt>Cloneable Instance</dt>
+<dt>Cloneable Traits</dt>
</dl></dd>
<dt>Heterogenous Containers</dt>
<dd><dl>
-<dt><a href="cloneable/heterogenous_containers/extended_object_hierarhcy.html">Extended
+<dt><a href="cloneable/heterogenous_containers.html#cloneable.heterogenous_containers.extended_object_hierarhcy">Extended
 Object Hierarhcy</a></dt>
-<dt><a href="cloneable/heterogenous_containers/container_method_names.html">Container
+<dt><a href="cloneable/heterogenous_containers.html#cloneable.heterogenous_containers.container_method_names">Container
 Method Names</a></dt>
-<dt>List</dt>
-<dt>Vector</dt>
-<dt>Set</dt>
-<dt>Map</dt>
-<dt><a href="cloneable/heterogenous_containers/heterogenous_map.html">Heterogenous
+<dt>List</dt>
+<dt>Vector</dt>
+<dt>Set</dt>
+<dt>Map</dt>
+<dt><a href="cloneable/heterogenous_containers.html#cloneable.heterogenous_containers.heterogenous_map">Heterogenous
 Map</a></dt>
-<dt><a href="cloneable/heterogenous_containers/hashmap_and_hashset.html">HashMap
+<dt><a href="cloneable/heterogenous_containers.html#cloneable.heterogenous_containers.hashmap_and_hashset">HashMap
 and HashSet</a></dt>
</dl></dd>
</dl>
</div>
<a name="cloneable..motivation"></a><h4>
-<a name="id663315"></a>
+<a name="id649132"></a>
 <a class="link" href="index.html#cloneable..motivation">Motivation</a>
 </h4>

@@ -86,7 +86,7 @@
 safely clone and query individual object instances.
 
<a name="cloneable..description"></a><h4>
-<a name="id663331"></a>
+<a name="id649149"></a>
 <a class="link" href="index.html#cloneable..description">Description</a>
 </h4>

@@ -151,12 +151,32 @@
 The complete source code for the library, with unit-tests, are available in the
 Boost SVN respository here.
 
+<div class="section" title="Change Log">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="cloneable.change_log"></a><a class="link" href="index.html#cloneable.change_log" title="Change Log"> Change Log</a>
+</h2></div></div></div>
+<a name="cloneable.change_log.version_0_1"></a><h4>
+<a name="id649257"></a>
+ <a class="link" href="index.html#cloneable.change_log.version_0_1">Version 0.1</a>
+ </h4>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ Associative heterogenous containers
+ </li>
+<li class="listitem">
+ User-defined base classes
+ </li>
+<li class="listitem">
+ Created
+ </li>
+</ul></div>
+</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: July 05, 2009 at 10:42:31 GMT</td>
+<td align="left">Last revised: July 08, 2009 at 20:09:11 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="cloneable/change_log.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="cloneable/tutorial.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
</body>
</html>

Modified: sandbox/cloneable/libs/cloneable/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/cloneable/libs/cloneable/doc/html/standalone_HTML.manifest (original)
+++ sandbox/cloneable/libs/cloneable/doc/html/standalone_HTML.manifest 2009-07-08 16:10:31 EDT (Wed, 08 Jul 2009)
@@ -1,20 +1,3 @@
index.html
-cloneable/change_log.html
cloneable/tutorial.html
-cloneable/tutorial/simple_hierarchical_cloning.html
-cloneable/tutorial/controlling_construction.html
-cloneable/tutorial/using_external_types.html
-cloneable/tutorial/dealing_with_muliple_sub_objects.html
-cloneable/tutorial/customising_the_cloning_process.html
-cloneable/tutorial/using_custom_allocators.html
-cloneable/tutorial/cloneable_instance.html
-cloneable/tutorial/cloneable_traits.html
cloneable/heterogenous_containers.html
-cloneable/heterogenous_containers/extended_object_hierarhcy.html
-cloneable/heterogenous_containers/container_method_names.html
-cloneable/heterogenous_containers/list.html
-cloneable/heterogenous_containers/vector.html
-cloneable/heterogenous_containers/set.html
-cloneable/heterogenous_containers/map.html
-cloneable/heterogenous_containers/heterogenous_map.html
-cloneable/heterogenous_containers/hashmap_and_hashset.html

Date view	Thread view	Subject view	Author view