Changeset 54634


Ignore:
Timestamp:
Jul 4, 2009, 9:10:04 AM (9 years ago)
Author:
cschladetsch
Message:

updated docs

Location:
sandbox/cloneable/libs/cloneable/doc
Files:
8 added
13 edited

Legend:

Unmodified
Added
Removed
  • sandbox/cloneable/libs/cloneable/doc/Jamfile.v2

    r54593 r54634  
    66xml cloneable : cloneable.qbk ;
    77
    8 path-constant images : html/images ;
     8path-constant images : doc/html/images ;
    99
    1010boostbook standalone
  • sandbox/cloneable/libs/cloneable/doc/cloneable.qbk

    r54627 r54634  
    315315[endsect]
    316316
    317 [section Dealing with Muliple SubObjects]
    318 
    319 When dealing with types that have multiple cloneable sub-objects, we must use the
     317[section Dealing with Muliple Sub-Objects]
     318
     319When working with types that have multiple cloneable sub-objects, we must use the
    320320`clone_as<T>` and `create_as<T>` methods to disambiguate which sub-type to clone
    321321or create.
     
    352352no_default_construction will be thrown if you attempt to default-create a new S instance
    353353from a T instance.
    354 
    355 However, it is always safe to clone types that are not default constructable.
    356354
    357355[endsect]
     
    388386This example uses the heap to make clones; we will next see how to make
    389387clones using any standard-compliant allocator type.
    390 
    391 [endsect]
    392 
    393 [section Cloneable Traits]
    394 
    395 This is mostly relevant to library maintainers and is not important otherwise.
    396 
    397 To assist with dealing with cloneable objects in other systems, the following
    398 traits are provided:
    399 
    400 ``
    401 class Base { virtual ~Base() { } };
    402 struct T : base<T, Base> { };
    403 struct U : base<T, Base, no_default_construction> { };
    404 struct V { };
    405 
    406 BOOST_STATIC_ASSERT(cloneable::is_cloneable<T>::value);
    407 BOOST_STATIC_ASSERT(cloneable::is_cloneable<U>::value);
    408 BOOST_STATIC_ASSERT(!cloneable::is_cloneable<V>::value);
    409 BOOST_STATIC_ASSERT(cloneable::has_base<T,Base>::value);
    410 
    411 //BOOST_STATIC_ASSERT(cloneable::is_default_constructable<V>::value); compile-time error: no traits
    412 BOOST_STATIC_ASSERT(cloneable::is_default_constructable<T>::value);
    413 BOOST_STATIC_ASSERT(!cloneable::is_default_constructable<T>::value);
    414 ``
    415 
    416 More details are in the `clonable::traits<T>` structure.
    417388
    418389[endsect]
     
    477448[endsect]
    478449
    479 
    480 [endsect]
    481 
    482 [section Containers]
     450[section Cloneable Traits]
     451
     452This is mostly relevant to library maintainers and is not important otherwise.
     453
     454To assist with dealing with cloneable objects in other systems, the following
     455traits are provided:
     456
     457``
     458class Base { virtual ~Base() { } };
     459struct T : base<T, Base> { };
     460struct U : base<T, Base, no_default_construction> { };
     461struct V { };
     462
     463BOOST_STATIC_ASSERT(cloneable::is_cloneable<T>::value);
     464BOOST_STATIC_ASSERT(cloneable::is_cloneable<U>::value);
     465BOOST_STATIC_ASSERT(!cloneable::is_cloneable<V>::value);
     466BOOST_STATIC_ASSERT(cloneable::has_base<T,Base>::value);
     467
     468//BOOST_STATIC_ASSERT(cloneable::is_default_constructable<V>::value); compile-time error: no traits
     469BOOST_STATIC_ASSERT(cloneable::is_default_constructable<T>::value);
     470BOOST_STATIC_ASSERT(!cloneable::is_default_constructable<T>::value);
     471``
     472
     473More details are in the `clonable::traits<T>` structure.
     474
     475[endsect]
     476
     477
     478[endsect]
     479
     480[section Heterogenous Containers]
    483481
    484482This section of the tutorial presents the first glimpse of the so-called ['heterogenous containers]
     
    487485* `list<Base, Allocator>`
    488486* `vector<Base, Allocator>`
     487* `deque<Base, Allocator>`
     488* `chain<Base, LinkLength, Allocator>`
    489489* `map<Base, Predicate, Allocator>`
    490490* `set<Base, Predicate, Allocator>`
     491* `multimap<Base, Pred, Alloc>`
     492* `multiset<Base, Pred, Alloc>`
    491493* `hash_map<Base, Predicate, Hash, Allocator>`
    492494* `hash_set<Base, Predicate, Hash, Allocator>`
     495* `hash_multimap<Base, Pred, Hash, Alloc>`.
     496* `hash_multiset<Base, Pred, Hash, Alloc>`
    493497
    494498All of these containers store pointers to objects. However, they each expose their contained objects using value semantics.
    495 If this seems similar to Boost.PtrContainer, that is not coincidental, as these containers are based on a modified implementation
     499If this seems similar to [*Boost.PtrContainer], that is not coincidental, as these containers are based on a modified implementation
    496500of that library.
    497501
    498 You will have noted that each container is specialised over a Base type, rather than a concrete derived type. This is
    499 because they are intended to store base pointers. It may be surprising that `map<>` takes only one type - the Base type - of
    500 object to store, rather than the more familiar key and mapped types. This is because a heterogenous map provides
     502You will have noted that each container is specialised over a `Base` type, rather than a concrete derived type. This is
     503because they are intended to store base pointers.
     504
     505It may be surprising that `map<>` takes only one type - the `Base` type - of
     506objects to store, rather than the more familiar ['key] and ['mapped] types. This is because a heterogenous map provides
    501507an association between objects with the same base type.
    502508
     509All heterogenous containers create objects to be added 'in place', in storage created by the containers allocator.
     510As such, to add a new object to a heterogenous container, you provide the type and the construction arguments. Allocation
     511and construction is dealt with by the container, and, importantly, ['objects are not copied into the container]:
     512
     513``
     514container.add_method<Type>(construction args..);
     515``
     516
     517This means, for instance, that you can use non-default-constructable objects in heterogenous vectors.
     518
     519It also means that you can use objects that do not or cannot have assignment defined.
     520
     521Basically, as long as you can construct the object at all, you can use it in a heterogenous container.
     522
     523Importantly, clones are guaranteed to be created using the same allocator as that used to make the original objects.
     524
     525This is why it is
     526important that you overload `make_copy(abstract_allocator &) const`, rather than the `make_copy() const` method that
     527does not take an allocator. (['Indeed, there is a good case to be made for removing this second method from the library
     528completely - CJS]).
     529
    503530These containers will be presented in order, with some motivational examples which combines them. First, we shall
    504 extend our little Animal hierarchy to include an age member, and a comparison operator:
     531extend our little Animal hierarchy to include an age member, and comparison operators.
     532
     533[section Extended Object Hierarhcy]
     534
     535This is the definitions we will use in the following examples. First, let's look at a slightly
     536extended base type for our Animal hierarchy:
    505537
    506538``
     
    508540{
    509541        double age;
     542        string name;
     543       
    510544        Animal(double years_old = 0) : age(years_old) { }
     545        Animal(string n, double years_old = 0) : age(years_old), name(n) { }
    511546       
    512         bool operator<(const Animal &other) const
     547        friend bool operator==(const Animal &left, const Animal &right) const
    513548        {
    514                 return age < other.age;
     549                return left.age == right.age;
    515550        }
    516 };
    517 
     551        friend bool operator<(const Animal &left, const Animal &right) const
     552        {
     553                return left.age < right.age;
     554        }
     555        struct CompareNames
     556        {
     557                friend bool operator<(const Animal &left, const Animal &right) const
     558                {
     559                        return left.name < right.name;
     560                }
     561        };
     562};
     563``
     564
     565This is just a little more elaborate than the previous example hierarchy we used earlier in the tutorial.
     566We have added an `age` field for all animals, which is how old it is in years. Animals have relational
     567operators for testing equivalence and sorting. Another functor named `CompareNames` is provided, which
     568sorts by the name field of animals rather than age.
     569
     570You are aware that getting your base class right is very important to the strength and efficacy of the
     571hierarchy as a whole. At a minimum, you must of course use a virtual destructor. Getting the comparison
     572operators right is very important as well, but of course we can always add more sorting predicates such
     573as `CompareNames` as needed.
     574
     575What we would like to avoid is having a so-called ['fat interface] as the base class, which
     576has a lot of extra information that is only relevant to one or more derived types. Some of these issues
     577can be addressed with further use of interfaces and virtual methods to obtain sorting criteria.
     578
     579A full discussion on object-oriented design is beyond the scope of this brief tutorial - and I'm sure you're
     580very aware of the issues in any case. Suffice to say
     581that you should pay attention to how you design your base types. Always use a virtual
     582destructor, try to keep state to a minimum, and bear in mind how you will want to compare objects.
     583
     584Moving on, we define our derived types:
     585
     586``
    518587struct Cat : cloneable::base<Cat, Animal>
    519588{
    520         Cat(double age = 0) : base_type(age) { }
     589        Cat(string name, double age = 10) : Animal(name, age) { }
    521590};
    522591
    523592struct Dog : cloneable::base<Dog, Animal>
    524593{
    525         Dog(double age = 0) : base_type(age) { }
     594        Dog(string name, double age = 0) : Animal(name, age) { }
    526595};
    527596
    528597struct Labrador : Dog, cloneable::base<Labrador, Animal>
    529598{
    530         Labrador(double age = 0) : base_type(age) { }
    531 };
    532 
    533 ``
     599        bool is_guide_dog;
     600        Labrador(string name, bool can_lead, double age = 0) : Dog(name, age), is_guide_dog(can_lead) { }
     601};
     602``
     603
     604Labradors now have an extra field indicating that a given instance has been trained as a guide dog, and each Animal
     605type can be constructed by passing its name and age. Note that there are no default constructors for
     606any of the Animal types.
     607
     608Feel free to return to this page to refresh your memory as we walk through some
     609examples that use these definitions.
     610
     611First, a preamble on names and semantics.
     612
     613[endsect]
     614
     615[section Container Method Names]
     616
     617To add an element of type `Ty` to any heterogenous
     618container such as a `list`, `vector` or `set` we use the following syntax:
     619
     620``
     621container.add_method_name<Ty>(a0, a1,..., an);
     622``
     623
     624Specifically, we do not directly add an object to a heterogenous container. Rather, we specify the type of thing
     625to add, and provide any construction arguments. This is true as well for specifying
     626objects to search for in associative containers:
     627
     628``
     629container.find<Ty>(a0, a1,..., an);
     630``
     631
     632This creates a new object of type `Ty`, constructed with the provided arguments, and searches for it
     633in the container. But, I'm getting a little ahead of ourselves here - more on associative containers later; let's
     634look at that syntax again.
     635
     636The name for the method to add new objects to heterogenous sequence containers has gone from
     637being called `push_back` to `emplace_back` to `push_emplace_back`
     638and back to `push_back`. Similarly for associative containers the names have varied
     639from `insert` to `emplace` to `emplace_insert` and back to `insert`.
     640
     641The C++0x containers have emplace methods that insert a new object after a given iterator
     642location, by passing construction arguments. These are called `emplace` methods.
     643
     644This is similar to the way that objects are added to heterogenous containers, but not
     645the same. For all heterogenous containers, the process is to specify the type of thing
     646and any creation arguments. There is no need to specify an iterator, but there
     647is a need to specify the type explicitly. This is different to the C++0x containers, which
     648do not require the type.
     649
     650For this reason the names have changed and are yet to be settled. All suggestions
     651for the names of the methods, or namespaces, are welcome. I am sure they'll end up being
     652called something like `emplace_back` rather than `push_back`; but the difference is that
     653there is no `push_back` in a heterogenous container: everything is always ['emplaced],
     654so this is one reason why I've been vasilating over the naming conventions to use.
    534655
    535656With this in mind, let's visit the first container: the faithful list.
    536657
     658[endsect]
     659
    537660[section List]
    538661
    539 TODO
     662The first heterogenous container we'll look at is the `list`. It is very much like a standard `list<T>`.
     663But it is also very different:
    540664
    541665``
     
    543667
    544668List list;
    545 list.emplace_back<Cat>("sam", 12);
    546 list.emplace_back<Dog>("spot", 8);
    547 list.emplace_back<Labrador>("max", 14);
     669list.push_back<Cat>("sam", 12);
     670list.push_back<Dog>("spot", 8);
     671list.push_back<Labrador>("max", 14);
    548672
    549673List copy = list;
     
    554678
    555679The first thing you may notice is the strange way we add new items to a list. All heterogenous containers use ['emplace]
    556 semantics for adding or querying objects.
    557 
    558 This means that the container creates the objects 'in place', in storage created by the containers allocator.
    559 As such, to add a new object to a heterogenous container, you provide the type and the construction arguments.
    560 
    561 Clones are created using the same allocator as that used to make the original objects; this is why it is
    562 important that you overload `make_copy(abstract_allocator &) const`, rather than the `make_copy` method that
    563 does not take an allocator. Indeed, there is a good case to be made for removing this second method from the library
    564 completely.
    565 
    566 For now, it will be enough to absorb the emplace syntax, and to note that the cloned list called `copy` made
     680semantics for searching for existing objects or adding new objects.
     681
     682For now, it will be enough to absorb the ['emplacement syntax] for adding new elements, and to note that the cloned list called `copy` made
    567683a deep copy of the list; the underlying base pointers were not just copied - they were cloned.
    568684
     
    571687[section Vector]
    572688
    573 TODO
     689The vector gets the same treatment as lists, with the same syntax for adding new elements, but also some
     690extra methods for random access of specifically typed contained objects:
    574691
    575692``
    576693typedef heterogenous::vector<Animal> Vector;
    577694Vector vector;
    578 vector.emplace_back<Cat>("sam");
    579 vector.emplace_back<Dog>("spot");
    580 vector.emplace_back<Labrador>("max", 14);
     695vector.push_back<Cat>("sam");
     696vector.push_back<Dog>("spot");
     697vector.push_back<Labrador>("max", 14);
    581698
    582699Vector copy = vector;
     
    586703Dog &spot = vector.as<Dog>(1);
    587704
    588 ``
     705const Dog *maybe_dog = vector.cast<Dog>(0);
     706``
     707
     708['Again, the names here have undergone a number of changes and remain in flux. Suggestions welcome!]
     709
     710`push_back` works just like with `list` and is not surprising. But the `as` and `cast` methods are new.
     711
     712`vector::as` is the same as `vector::at` except that it requires a type to convert to. `at` will return
     713a base reference. `as` returns a derived-type reference, or throws `std::bad_cast`.
     714
     715`vector::cast` (['another name in need of a better name]) returns a pointer of the given type to
     716the specified element, or returns the null pointer if conversion was not possible or ambiguous.
     717
     718The other members in `vector` are largely what you would expect with no real surprises. See the reference for complete details.
    589719
    590720[endsect]
     
    592722[section Set]
    593723
    594 TODO
     724So far we have been intoduced to the two basic heterogenous sequence containers, `list` and `vector`. The main
     725difference over the standard containers is how you add new objects to them, and that they are, well, heterogenous.
     726You can store any type of object in them that derives from the base type that you used to define the list or vector.
     727
     728Things start to get interesting with the associative containers `set` and `map`. Here we take a quick look
     729at how we might use a heterogenous set to store a collection of animals.
    595730
    596731``
     
    600735        Set set;
    601736       
    602         Cat &sam = set.emplace<Cat>("sam", 1.5);
    603         Dog &spot = set.emplace<Dog>("spot", 3);
    604         Labrador &max = set.emplace<Labrador>("max", 14);
     737        const Cat &sam = set.emplace<Cat>("sam", 1.5).deref();
     738        const Dog &spot = set.emplace<Dog>("spot", 3).deref();
     739        const Labrador &max = set.emplace<Labrador>("max", 14).deref();
    605740
    606741        Set copy = set;
    607742
    608         Set::iterator dog = copy.find<Dog>(14);
    609         Set::iterator any = copy.find<Animal>(1.5);
     743        Set::iterator dog = copy.find<Dog>(14);         // find a dog aged 14
     744        Set::iterator any = copy.find<Animal>(1.5);     // find any animal aged 1.5
     745        Set::iterator cat = copy.find<Cat>(3);          // find a cat aged 3
    610746
    611747        assert(&*dog == &max);
    612748        assert(&*any == &sam);
     749        assert(cat == set.end());
    613750       
    614751        return 0;
    615752}
    616 
    617753``
    618754
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/change_log.html

    r54627 r54634  
    2828</h2></div></div></div>
    2929<a name="cloneable.change_log.version_0_1"></a><h4>
    30 <a name="id663379"></a>
     30<a name="id646995"></a>
    3131      <a class="link" href="change_log.html#cloneable.change_log.version_0_1">Version 0.1</a>
    3232    </h4>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/containers.html

    r54592 r54634  
    77<link rel="home" href="../index.html" title="Cloneable 0.1">
    88<link rel="up" href="../index.html" title="Cloneable 0.1">
    9 <link rel="prev" href="tutorial/using_custom_allocators.html" title="Using Custom Allocators">
    10 <link rel="next" href="containers/list.html" title="List">
     9<link rel="prev" href="tutorial/cloneable_traits.html" title="Cloneable Traits">
     10<link rel="next" href="containers/extended_object_hierarhcy.html" title="Extended Object Hierarhcy">
    1111</head>
    1212<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
     
    2121<hr>
    2222<div class="spirit-nav">
    23 <a accesskey="p" href="tutorial/using_custom_allocators.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="containers/list.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
     23<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="containers/extended_object_hierarhcy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
    2424</div>
    2525<div class="section" title="Containers">
     
    2828</h2></div></div></div>
    2929<div class="toc"><dl>
     30<dt><span class="section"><a href="containers/extended_object_hierarhcy.html">Extended
     31      Object Hierarhcy</a></span></dt>
     32<dt><span class="section"><a href="containers/container_method_names.html">Container
     33      Method Names</a></span></dt>
    3034<dt><span class="section"><a href="containers/list.html">List</a></span></dt>
    3135<dt><span class="section"><a href="containers/vector.html">Vector</a></span></dt>
     
    4246<li class="listitem"><code class="computeroutput"><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
    4347<li class="listitem"><code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
     48<li class="listitem"><code class="computeroutput"><span class="identifier">deque</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
     49<li class="listitem"><code class="computeroutput"><span class="identifier">chain</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">LinkLength</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
    4450<li class="listitem"><code class="computeroutput"><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
    4551<li class="listitem"><code class="computeroutput"><span class="identifier">set</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
     52<li class="listitem"><code class="computeroutput"><span class="identifier">multimap</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span></code></li>
     53<li class="listitem"><code class="computeroutput"><span class="identifier">multiset</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span></code></li>
    4654<li class="listitem"><code class="computeroutput"><span class="identifier">hash_map</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
    4755<li class="listitem"><code class="computeroutput"><span class="identifier">hash_set</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span></code></li>
     56<li class="listitem">
     57<code class="computeroutput"><span class="identifier">hash_multimap</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span></code>.
     58      </li>
     59<li class="listitem"><code class="computeroutput"><span class="identifier">hash_multiset</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span></code></li>
    4860</ul></div>
    4961<p>
    5062      All of these containers store pointers to objects. However, they each expose
    51       their contained objects using value semantics. If this seems similar to Boost.PtrContainer,
    52       that is not coincidental, as these containers are based on a modified implementation
    53       of that library.
     63      their contained objects using value semantics. If this seems similar to <span class="bold"><strong>Boost.PtrContainer</strong></span>, that is not coincidental, as these
     64      containers are based on a modified implementation of that library.
    5465    </p>
    5566<p>
    56       You will have noted that each container is specialised over a Base type, rather
    57       than a concrete derived type. This is because they are intended to store base
    58       pointers. It may be surprising that <code class="computeroutput"><span class="identifier">map</span><span class="special">&lt;&gt;</span></code> takes only one type - the Base type
    59       - of object to store, rather than the more familiar key and mapped types. This
    60       is because a heterogenous map provides an association between objects with
    61       the same base type.
     67      You will have noted that each container is specialised over a <code class="computeroutput"><span class="identifier">Base</span></code> type, rather than a concrete derived
     68      type. This is because they are intended to store base pointers.
     69    </p>
     70<p>
     71      It may be surprising that <code class="computeroutput"><span class="identifier">map</span><span class="special">&lt;&gt;</span></code> takes only one type - the <code class="computeroutput"><span class="identifier">Base</span></code> type - of objects to store, rather than
     72      the more familiar <span class="emphasis"><em>key</em></span> and <span class="emphasis"><em>mapped</em></span>
     73      types. This is because a heterogenous map provides an association between objects
     74      with the same base type.
     75    </p>
     76<p>
     77      All heterogenous containers create objects to be added 'in place', in storage
     78      created by the containers allocator. As such, to add a new object to a heterogenous
     79      container, you provide the type and the construction arguments. Allocation
     80      and construction is dealt with by the container, and, importantly, <span class="emphasis"><em>objects
     81      are not copied into the container</em></span>:
     82    </p>
     83<p>
     84     
     85</p>
     86<pre class="programlisting"><span class="identifier">container</span><span class="special">.</span><span class="identifier">add_method</span><span class="special">&lt;</span><span class="identifier">Type</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">..);</span>
     87</pre>
     88<p>
     89    </p>
     90<p>
     91      This means, for instance, that you can use non-default-constructable objects
     92      in heterogenous vectors.
     93    </p>
     94<p>
     95      It also means that you can use objects that do not or cannot have assignment
     96      defined.
     97    </p>
     98<p>
     99      Basically, as long as you can construct the object at all, you can use it in
     100      a heterogenous container.
     101    </p>
     102<p>
     103      Importantly, clones are guaranteed to be created using the same allocator as
     104      that used to make the original objects.
     105    </p>
     106<p>
     107      This is why it is important that you overload <code class="computeroutput"><span class="identifier">make_copy</span><span class="special">(</span><span class="identifier">abstract_allocator</span>
     108      <span class="special">&amp;)</span> <span class="keyword">const</span></code>,
     109      rather than the <code class="computeroutput"><span class="identifier">make_copy</span><span class="special">()</span>
     110      <span class="keyword">const</span></code> method that does not take an allocator.
     111      (<span class="emphasis"><em>Indeed, there is a good case to be made for removing this second
     112      method from the library completely</em></span>).
    62113    </p>
    63114<p>
    64115      These containers will be presented in order, with some motivational examples
    65116      which combines them. First, we shall extend our little Animal hierarchy to
    66       include an age member, and a comparison operator:
    67     </p>
    68 <p>
    69      
    70 </p>
    71 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Animal</span>
    72 <span class="special">{</span>
    73         <span class="keyword">double</span> <span class="identifier">age</span><span class="special">;</span>
    74         <span class="identifier">Animal</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">years_old</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">age</span><span class="special">(</span><span class="identifier">years_old</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
    75        
    76         <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">Animal</span> <span class="special">&amp;</span><span class="identifier">other</span><span class="special">)</span> <span class="keyword">const</span>
    77         <span class="special">{</span>
    78                 <span class="keyword">return</span> <span class="identifier">age</span> <span class="special">&lt;</span> <span class="identifier">other</span><span class="special">.</span><span class="identifier">age</span><span class="special">;</span>
    79         <span class="special">}</span>
    80 <span class="special">};</span>
    81 
    82 <span class="keyword">struct</span> <span class="identifier">Cat</span> <span class="special">:</span> <span class="identifier">cloneable</span><span class="special">::</span><span class="identifier">base</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">,</span> <span class="identifier">Animal</span><span class="special">&gt;</span>
    83 <span class="special">{</span>
    84         <span class="identifier">Cat</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">age</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">base_type</span><span class="special">(</span><span class="identifier">age</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
    85 <span class="special">};</span>
    86 
    87 <span class="keyword">struct</span> <span class="identifier">Dog</span> <span class="special">:</span> <span class="identifier">cloneable</span><span class="special">::</span><span class="identifier">base</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">,</span> <span class="identifier">Animal</span><span class="special">&gt;</span>
    88 <span class="special">{</span>
    89         <span class="identifier">Dog</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">age</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">base_type</span><span class="special">(</span><span class="identifier">age</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
    90 <span class="special">};</span>
    91 
    92 <span class="keyword">struct</span> <span class="identifier">Labrador</span> <span class="special">:</span> <span class="identifier">Dog</span><span class="special">,</span> <span class="identifier">cloneable</span><span class="special">::</span><span class="identifier">base</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">,</span> <span class="identifier">Animal</span><span class="special">&gt;</span>
    93 <span class="special">{</span>
    94         <span class="identifier">Labrador</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">age</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">base_type</span><span class="special">(</span><span class="identifier">age</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
    95 <span class="special">};</span>
    96 
    97 </pre>
    98 <p>
    99     </p>
    100 <p>
    101       With this in mind, let's visit the first container: the faithful list.
     117      include an age member, and comparison operators.
    102118    </p>
    103119</div>
     
    112128<hr>
    113129<div class="spirit-nav">
    114 <a accesskey="p" href="tutorial/using_custom_allocators.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="containers/list.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
     130<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="containers/extended_object_hierarhcy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
    115131</div>
    116132</body>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/containers/list.html

    r54621 r54634  
    77<link rel="home" href="../../index.html" title="Cloneable 0.1">
    88<link rel="up" href="../containers.html" title="Containers">
    9 <link rel="prev" href="../containers.html" title="Containers">
     9<link rel="prev" href="container_method_names.html" title="Container Method Names">
    1010<link rel="next" href="vector.html" title="Vector">
    1111</head>
     
    2121<hr>
    2222<div class="spirit-nav">
    23 <a accesskey="p" href="../containers.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../containers.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="vector.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     23<a accesskey="p" href="container_method_names.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../containers.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="vector.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    2424</div>
    2525<div class="section" title="List">
     
    2828</h3></div></div></div>
    2929<p>
    30         TODO
     30        The first heterogenous container we'll look at is the <code class="computeroutput"><span class="identifier">list</span></code>.
     31        It is very much like a standard <code class="computeroutput"><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>.
     32        But it is also very different:
    3133      </p>
    3234<p>
     
    3638
    3739<span class="identifier">List</span> <span class="identifier">list</span><span class="special">;</span>
    38 <span class="identifier">list</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="string">"sam"</span><span class="special">,</span> <span class="number">12</span><span class="special">);</span>
    39 <span class="identifier">list</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="string">"spot"</span><span class="special">,</span> <span class="number">8</span><span class="special">);</span>
    40 <span class="identifier">list</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">&gt;(</span><span class="string">"max"</span><span class="special">,</span> <span class="number">14</span><span class="special">);</span>
     40<span class="identifier">list</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="string">"sam"</span><span class="special">,</span> <span class="number">12</span><span class="special">);</span>
     41<span class="identifier">list</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="string">"spot"</span><span class="special">,</span> <span class="number">8</span><span class="special">);</span>
     42<span class="identifier">list</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">&gt;(</span><span class="string">"max"</span><span class="special">,</span> <span class="number">14</span><span class="special">);</span>
    4143
    4244<span class="identifier">List</span> <span class="identifier">copy</span> <span class="special">=</span> <span class="identifier">list</span><span class="special">;</span>
     
    5052        The first thing you may notice is the strange way we add new items to a list.
    5153        All heterogenous containers use <span class="emphasis"><em>emplace</em></span> semantics for
    52         adding or querying objects.
     54        searching for existing objects or adding new objects.
    5355      </p>
    5456<p>
    55         This means that the container creates the objects 'in place', in storage
    56         created by the containers allocator. As such, to add a new object to a heterogenous
    57         container, you provide the type and the construction arguments.
    58       </p>
    59 <p>
    60         Clones are created using the same allocator as that used to make the original
    61         objects; this is why it is important that you overload <code class="computeroutput"><span class="identifier">make_copy</span><span class="special">(</span><span class="identifier">abstract_allocator</span>
    62         <span class="special">&amp;)</span> <span class="keyword">const</span></code>,
    63         rather than the <code class="computeroutput"><span class="identifier">make_copy</span></code>
    64         method that does not take an allocator. Indeed, there is a good case to be
    65         made for removing this second method from the library completely.
    66       </p>
    67 <p>
    68         For now, it will be enough to absorb the emplace syntax, and to note that
    69         the cloned list called <code class="computeroutput"><span class="identifier">copy</span></code>
    70         made a deep copy of the list; the underlying base pointers were not just
    71         copied - they were cloned.
     57        For now, it will be enough to absorb the <span class="emphasis"><em>emplacement syntax</em></span>
     58        for adding new elements, and to note that the cloned list called <code class="computeroutput"><span class="identifier">copy</span></code> made a deep copy of the list; the
     59        underlying base pointers were not just copied - they were cloned.
    7260      </p>
    7361</div>
     
    8270<hr>
    8371<div class="spirit-nav">
    84 <a accesskey="p" href="../containers.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../containers.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="vector.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     72<a accesskey="p" href="container_method_names.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../containers.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="vector.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    8573</div>
    8674</body>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/containers/set.html

    r54621 r54634  
    2828</h3></div></div></div>
    2929<p>
    30         TODO
     30        So far we have been intoduced to the two basic heterogenous sequence containers,
     31        <code class="computeroutput"><span class="identifier">list</span></code> and <code class="computeroutput"><span class="identifier">vector</span></code>.
     32        The main difference over the standard containers is how you add new objects
     33        to them, and that they are, well, heterogenous. You can store any type of
     34        object in them that derives from the base type that you used to define the
     35        list or vector.
     36      </p>
     37<p>
     38        Things start to get interesting with the associative containers <code class="computeroutput"><span class="identifier">set</span></code> and <code class="computeroutput"><span class="identifier">map</span></code>.
     39        Here we take a quick look at how we might use a heterogenous set to store
     40        a collection of animals.
    3141      </p>
    3242<p>
     
    3848        <span class="identifier">Set</span> <span class="identifier">set</span><span class="special">;</span>
    3949       
    40         <span class="identifier">Cat</span> <span class="special">&amp;</span><span class="identifier">sam</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="string">"sam"</span><span class="special">,</span> <span class="number">1.5</span><span class="special">);</span>
    41         <span class="identifier">Dog</span> <span class="special">&amp;</span><span class="identifier">spot</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="string">"spot"</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span>
    42         <span class="identifier">Labrador</span> <span class="special">&amp;</span><span class="identifier">max</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">&gt;(</span><span class="string">"max"</span><span class="special">,</span> <span class="number">14</span><span class="special">);</span>
     50        <span class="keyword">const</span> <span class="identifier">Cat</span> <span class="special">&amp;</span><span class="identifier">sam</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="string">"sam"</span><span class="special">,</span> <span class="number">1.5</span><span class="special">).</span><span class="identifier">deref</span><span class="special">();</span>
     51        <span class="keyword">const</span> <span class="identifier">Dog</span> <span class="special">&amp;</span><span class="identifier">spot</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="string">"spot"</span><span class="special">,</span> <span class="number">3</span><span class="special">).</span><span class="identifier">deref</span><span class="special">();</span>
     52        <span class="keyword">const</span> <span class="identifier">Labrador</span> <span class="special">&amp;</span><span class="identifier">max</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">&gt;(</span><span class="string">"max"</span><span class="special">,</span> <span class="number">14</span><span class="special">).</span><span class="identifier">deref</span><span class="special">();</span>
    4353
    4454        <span class="identifier">Set</span> <span class="identifier">copy</span> <span class="special">=</span> <span class="identifier">set</span><span class="special">;</span>
    4555
    46         <span class="identifier">Set</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">dog</span> <span class="special">=</span> <span class="identifier">copy</span><span class="special">.</span><span class="identifier">find</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="number">14</span><span class="special">);</span>
    47         <span class="identifier">Set</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">any</span> <span class="special">=</span> <span class="identifier">copy</span><span class="special">.</span><span class="identifier">find</span><span class="special">&lt;</span><span class="identifier">Animal</span><span class="special">&gt;(</span><span class="number">1.5</span><span class="special">);</span>
    48 
     56        <span class="identifier">Set</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">dog</span> <span class="special">=</span> <span class="identifier">copy</span><span class="special">.</span><span class="identifier">find</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="number">14</span><span class="special">);</span>         <span class="comment">// find a dog aged 14
     57</span> <span class="identifier">Set</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">any</span> <span class="special">=</span> <span class="identifier">copy</span><span class="special">.</span><span class="identifier">find</span><span class="special">&lt;</span><span class="identifier">Animal</span><span class="special">&gt;(</span><span class="number">1.5</span><span class="special">);</span>     <span class="comment">// find any animal aged 1.5
     58</span> <span class="identifier">Set</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">cat</span> <span class="special">=</span> <span class="identifier">copy</span><span class="special">.</span><span class="identifier">find</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="number">3</span><span class="special">);</span>          <span class="comment">// find a cat aged 3
     59</span>
    4960        <span class="identifier">assert</span><span class="special">(&amp;*</span><span class="identifier">dog</span> <span class="special">==</span> <span class="special">&amp;</span><span class="identifier">max</span><span class="special">);</span>
    5061        <span class="identifier">assert</span><span class="special">(&amp;*</span><span class="identifier">any</span> <span class="special">==</span> <span class="special">&amp;</span><span class="identifier">sam</span><span class="special">);</span>
     62        <span class="identifier">assert</span><span class="special">(</span><span class="identifier">cat</span> <span class="special">==</span> <span class="identifier">set</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
    5163       
    5264        <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
    5365<span class="special">}</span>
    54 
    5566</pre>
    5667<p>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/containers/vector.html

    r54621 r54634  
    2828</h3></div></div></div>
    2929<p>
    30         TODO
     30        The vector gets the same treatment as lists, with the same syntax for adding
     31        new elements, but also some extra methods for random access of specifically
     32        typed contained objects:
    3133      </p>
    3234<p>
     
    3537<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">heterogenous</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">Animal</span><span class="special">&gt;</span> <span class="identifier">Vector</span><span class="special">;</span>
    3638<span class="identifier">Vector</span> <span class="identifier">vector</span><span class="special">;</span>
    37 <span class="identifier">vector</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="string">"sam"</span><span class="special">);</span>
    38 <span class="identifier">vector</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="string">"spot"</span><span class="special">);</span>
    39 <span class="identifier">vector</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">&gt;(</span><span class="string">"max"</span><span class="special">,</span> <span class="number">14</span><span class="special">);</span>
     39<span class="identifier">vector</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">&lt;</span><span class="identifier">Cat</span><span class="special">&gt;(</span><span class="string">"sam"</span><span class="special">);</span>
     40<span class="identifier">vector</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="string">"spot"</span><span class="special">);</span>
     41<span class="identifier">vector</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">&lt;</span><span class="identifier">Labrador</span><span class="special">&gt;(</span><span class="string">"max"</span><span class="special">,</span> <span class="number">14</span><span class="special">);</span>
    4042
    4143<span class="identifier">Vector</span> <span class="identifier">copy</span> <span class="special">=</span> <span class="identifier">vector</span><span class="special">;</span>
     
    4547<span class="identifier">Dog</span> <span class="special">&amp;</span><span class="identifier">spot</span> <span class="special">=</span> <span class="identifier">vector</span><span class="special">.</span><span class="identifier">as</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="number">1</span><span class="special">);</span>
    4648
     49<span class="keyword">const</span> <span class="identifier">Dog</span> <span class="special">*</span><span class="identifier">maybe_dog</span> <span class="special">=</span> <span class="identifier">vector</span><span class="special">.</span><span class="identifier">cast</span><span class="special">&lt;</span><span class="identifier">Dog</span><span class="special">&gt;(</span><span class="number">0</span><span class="special">);</span>
    4750</pre>
    4851<p>
     52      </p>
     53<p>
     54        <span class="emphasis"><em>Again, the names here have undergone a number of changes and remain
     55        in flux. Suggestions welcome!</em></span>
     56      </p>
     57<p>
     58        <code class="computeroutput"><span class="identifier">push_back</span></code> works just like
     59        with <code class="computeroutput"><span class="identifier">list</span></code> and is not surprising.
     60        But the <code class="computeroutput"><span class="identifier">as</span></code> and <code class="computeroutput"><span class="identifier">cast</span></code> methods are new.
     61      </p>
     62<p>
     63        <code class="computeroutput"><span class="identifier">vector</span><span class="special">::</span><span class="identifier">as</span></code> is the same as <code class="computeroutput"><span class="identifier">vector</span><span class="special">::</span><span class="identifier">at</span></code> except
     64        that it requires a type to convert to. <code class="computeroutput"><span class="identifier">at</span></code>
     65        will return a base reference. <code class="computeroutput"><span class="identifier">as</span></code>
     66        returns a derived-type reference, or throws <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_cast</span></code>.
     67      </p>
     68<p>
     69        <code class="computeroutput"><span class="identifier">vector</span><span class="special">::</span><span class="identifier">cast</span></code> (<span class="emphasis"><em>another name in need of
     70        a better name</em></span>) returns a pointer of the given type to the specified
     71        element, or returns the null pointer if conversion was not possible or ambiguous.
     72      </p>
     73<p>
     74        The other members in <code class="computeroutput"><span class="identifier">vector</span></code>
     75        are largely what you would expect with no real surprises. See the reference
     76        for complete details.
    4977      </p>
    5078</div>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial.html

    r54627 r54634  
    3434<dt><span class="section"><a href="tutorial/using_external_types.html">Using External
    3535      Types</a></span></dt>
    36 <dt><span class="section"><a href="tutorial/dealing_with_muliple_subobjects.html">Dealing
    37       with Muliple SubObjects</a></span></dt>
     36<dt><span class="section"><a href="tutorial/dealing_with_muliple_sub_objects.html">Dealing
     37      with Muliple Sub-Objects</a></span></dt>
    3838<dt><span class="section"><a href="tutorial/customising_the_cloning_process.html">Customising
    3939      the Cloning Process</a></span></dt>
    40 <dt><span class="section"><a href="tutorial/cloneable_traits.html">Cloneable Traits</a></span></dt>
    4140<dt><span class="section"><a href="tutorial/using_custom_allocators.html">Using Custom
    4241      Allocators</a></span></dt>
     42<dt><span class="section"><a href="tutorial/cloneable_traits.html">Cloneable Traits</a></span></dt>
    4343</dl></div>
    4444<p>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial/customising_the_cloning_process.html

    r54627 r54634  
    77<link rel="home" href="../../index.html" title="Cloneable 0.1">
    88<link rel="up" href="../tutorial.html" title="Tutorial">
    9 <link rel="prev" href="dealing_with_muliple_subobjects.html" title="Dealing with Muliple SubObjects">
    10 <link rel="next" href="cloneable_traits.html" title="Cloneable Traits">
     9<link rel="prev" href="dealing_with_muliple_sub_objects.html" title="Dealing with Muliple Sub-Objects">
     10<link rel="next" href="using_custom_allocators.html" title="Using Custom Allocators">
    1111</head>
    1212<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
     
    2121<hr>
    2222<div class="spirit-nav">
    23 <a accesskey="p" href="dealing_with_muliple_subobjects.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="cloneable_traits.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     23<a accesskey="p" href="dealing_with_muliple_sub_objects.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="using_custom_allocators.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    2424</div>
    2525<div class="section" title="Customising the Cloning Process">
     
    7777<hr>
    7878<div class="spirit-nav">
    79 <a accesskey="p" href="dealing_with_muliple_subobjects.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="cloneable_traits.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     79<a accesskey="p" href="dealing_with_muliple_sub_objects.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="using_custom_allocators.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    8080</div>
    8181</body>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial/using_custom_allocators.html

    r54627 r54634  
    77<link rel="home" href="../../index.html" title="Cloneable 0.1">
    88<link rel="up" href="../tutorial.html" title="Tutorial">
    9 <link rel="prev" href="cloneable_traits.html" title="Cloneable Traits">
    10 <link rel="next" href="../containers.html" title="Containers">
     9<link rel="prev" href="customising_the_cloning_process.html" title="Customising the Cloning Process">
     10<link rel="next" href="cloneable_traits.html" title="Cloneable Traits">
    1111</head>
    1212<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
     
    2121<hr>
    2222<div class="spirit-nav">
    23 <a accesskey="p" href="cloneable_traits.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="../containers.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     23<a accesskey="p" href="customising_the_cloning_process.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="cloneable_traits.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    2424</div>
    2525<div class="section" title="Using Custom Allocators">
     
    123123<hr>
    124124<div class="spirit-nav">
    125 <a accesskey="p" href="cloneable_traits.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="../containers.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     125<a accesskey="p" href="customising_the_cloning_process.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="cloneable_traits.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    126126</div>
    127127</body>
  • sandbox/cloneable/libs/cloneable/doc/html/cloneable/tutorial/using_external_types.html

    r54627 r54634  
    88<link rel="up" href="../tutorial.html" title="Tutorial">
    99<link rel="prev" href="controlling_construction.html" title="Controlling Construction">
    10 <link rel="next" href="dealing_with_muliple_subobjects.html" title="Dealing with Muliple SubObjects">
     10<link rel="next" href="dealing_with_muliple_sub_objects.html" title="Dealing with Muliple Sub-Objects">
    1111</head>
    1212<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
     
    2121<hr>
    2222<div class="spirit-nav">
    23 <a accesskey="p" href="controlling_construction.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="dealing_with_muliple_subobjects.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     23<a accesskey="p" href="controlling_construction.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="dealing_with_muliple_sub_objects.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    2424</div>
    2525<div class="section" title="Using External Types">
     
    9999<hr>
    100100<div class="spirit-nav">
    101 <a accesskey="p" href="controlling_construction.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="dealing_with_muliple_subobjects.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
     101<a accesskey="p" href="controlling_construction.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.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="dealing_with_muliple_sub_objects.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
    102102</div>
    103103</body>
  • sandbox/cloneable/libs/cloneable/doc/html/index.html

    r54627 r54634  
    2929<div><p class="copyright">Copyright © 2009 Christian Schladetsch</p></div>
    3030<div><div class="legalnotice" title="Legal Notice">
    31 <a name="id663289"></a><p>
     31<a name="id646905"></a><p>
    3232        Distributed under the Boost Software License, Version 1.0. (See accompanying
    3333        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
     
    5050<dt><span class="section"><a href="cloneable/tutorial/using_external_types.html">Using External
    5151      Types</a></span></dt>
    52 <dt><span class="section"><a href="cloneable/tutorial/dealing_with_muliple_subobjects.html">Dealing
    53       with Muliple SubObjects</a></span></dt>
     52<dt><span class="section"><a href="cloneable/tutorial/dealing_with_muliple_sub_objects.html">Dealing
     53      with Muliple Sub-Objects</a></span></dt>
    5454<dt><span class="section"><a href="cloneable/tutorial/customising_the_cloning_process.html">Customising
    5555      the Cloning Process</a></span></dt>
    56 <dt><span class="section"><a href="cloneable/tutorial/cloneable_traits.html">Cloneable Traits</a></span></dt>
    5756<dt><span class="section"><a href="cloneable/tutorial/using_custom_allocators.html">Using Custom
    5857      Allocators</a></span></dt>
     58<dt><span class="section"><a href="cloneable/tutorial/cloneable_traits.html">Cloneable Traits</a></span></dt>
    5959</dl></dd>
    60 <dt><span class="section"><a href="cloneable/containers.html">Containers</a></span></dt>
     60<dt><span class="section"><a href="cloneable/heterogenous_containers.html">Heterogenous Containers</a></span></dt>
    6161<dd><dl>
    62 <dt><span class="section"><a href="cloneable/containers/list.html">List</a></span></dt>
    63 <dt><span class="section"><a href="cloneable/containers/vector.html">Vector</a></span></dt>
    64 <dt><span class="section"><a href="cloneable/containers/set.html">Set</a></span></dt>
    65 <dt><span class="section"><a href="cloneable/containers/map.html">Map</a></span></dt>
    66 <dt><span class="section"><a href="cloneable/containers/hashmap_and_hashset.html">HashMap and
    67       HashSet</a></span></dt>
     62<dt><span class="section"><a href="cloneable/heterogenous_containers/extended_object_hierarhcy.html">Extended
     63      Object Hierarhcy</a></span></dt>
     64<dt><span class="section"><a href="cloneable/heterogenous_containers/container_method_names.html">Container
     65      Method Names</a></span></dt>
     66<dt><span class="section"><a href="cloneable/heterogenous_containers/list.html">List</a></span></dt>
     67<dt><span class="section"><a href="cloneable/heterogenous_containers/vector.html">Vector</a></span></dt>
     68<dt><span class="section"><a href="cloneable/heterogenous_containers/set.html">Set</a></span></dt>
     69<dt><span class="section"><a href="cloneable/heterogenous_containers/map.html">Map</a></span></dt>
     70<dt><span class="section"><a href="cloneable/heterogenous_containers/hashmap_and_hashset.html">HashMap
     71      and HashSet</a></span></dt>
    6872</dl></dd>
    6973</dl>
     
    7175</div>
    7276<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
    73 <td align="left"><p><small>Last revised: July 04, 2009 at 02:08:30 GMT</small></p></td>
     77<td align="left"><p><small>Last revised: July 04, 2009 at 09:08:01 GMT</small></p></td>
    7478<td align="right"><div class="copyright-footer"></div></td>
    7579</tr></table>
  • sandbox/cloneable/libs/cloneable/doc/html/standalone_HTML.manifest

    r54627 r54634  
    66cloneable/tutorial/controlling_construction.html
    77cloneable/tutorial/using_external_types.html
    8 cloneable/tutorial/dealing_with_muliple_subobjects.html
     8cloneable/tutorial/dealing_with_muliple_sub_objects.html
    99cloneable/tutorial/customising_the_cloning_process.html
     10cloneable/tutorial/using_custom_allocators.html
    1011cloneable/tutorial/cloneable_traits.html
    11 cloneable/tutorial/using_custom_allocators.html
    12 cloneable/containers.html
    13 cloneable/containers/list.html
    14 cloneable/containers/vector.html
    15 cloneable/containers/set.html
    16 cloneable/containers/map.html
    17 cloneable/containers/hashmap_and_hashset.html
     12cloneable/heterogenous_containers.html
     13cloneable/heterogenous_containers/extended_object_hierarhcy.html
     14cloneable/heterogenous_containers/container_method_names.html
     15cloneable/heterogenous_containers/list.html
     16cloneable/heterogenous_containers/vector.html
     17cloneable/heterogenous_containers/set.html
     18cloneable/heterogenous_containers/map.html
     19cloneable/heterogenous_containers/hashmap_and_hashset.html
Note: See TracChangeset for help on using the changeset viewer.