Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r74077 - in trunk/libs/container: . doc doc/html doc/html/images example proj proj/vc7ide test
From: igaztanaga_at_[hidden]
Date: 2011-08-26 14:26:49


Author: igaztanaga
Date: 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
New Revision: 74077
URL: http://svn.boost.org/trac/boost/changeset/74077

Log:
First inclusion in the repository
Added:
   trunk/libs/container/ (props changed)
   trunk/libs/container/doc/ (props changed)
   trunk/libs/container/doc/Jamfile.v2 (contents, props changed)
   trunk/libs/container/doc/container.qbk (contents, props changed)
   trunk/libs/container/doc/html/ (props changed)
   trunk/libs/container/doc/html/boostbook.css (contents, props changed)
   trunk/libs/container/doc/html/images/ (props changed)
   trunk/libs/container/doc/html/images/blank.png (contents, props changed)
   trunk/libs/container/doc/html/images/caution.png (contents, props changed)
   trunk/libs/container/doc/html/images/draft.png (contents, props changed)
   trunk/libs/container/doc/html/images/home.png (contents, props changed)
   trunk/libs/container/doc/html/images/important.png (contents, props changed)
   trunk/libs/container/doc/html/images/next.png (contents, props changed)
   trunk/libs/container/doc/html/images/note.png (contents, props changed)
   trunk/libs/container/doc/html/images/prev.png (contents, props changed)
   trunk/libs/container/doc/html/images/stable_vector.png (contents, props changed)
   trunk/libs/container/doc/html/images/tip.png (contents, props changed)
   trunk/libs/container/doc/html/images/toc-blank.png (contents, props changed)
   trunk/libs/container/doc/html/images/toc-minus.png (contents, props changed)
   trunk/libs/container/doc/html/images/toc-plus.png (contents, props changed)
   trunk/libs/container/doc/html/images/up.png (contents, props changed)
   trunk/libs/container/doc/html/images/warning.png (contents, props changed)
   trunk/libs/container/doc/html/index.html (contents, props changed)
   trunk/libs/container/doc/html/reference.css (contents, props changed)
   trunk/libs/container/example/ (props changed)
   trunk/libs/container/example/Jamfile.v2 (contents, props changed)
   trunk/libs/container/example/doc_emplace.cpp (contents, props changed)
   trunk/libs/container/example/doc_move_containers.cpp (contents, props changed)
   trunk/libs/container/example/doc_recursive_containers.cpp (contents, props changed)
   trunk/libs/container/example/doc_type_erasure.cpp (contents, props changed)
   trunk/libs/container/index.html (contents, props changed)
   trunk/libs/container/proj/ (props changed)
   trunk/libs/container/proj/to-do.txt (contents, props changed)
   trunk/libs/container/proj/vc7ide/ (props changed)
   trunk/libs/container/proj/vc7ide/container.sln (contents, props changed)
   trunk/libs/container/proj/vc7ide/container.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/deque_test.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/flat_tree_test.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/list_ex.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/slist_test.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/stable_vector_test.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/string_test.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/tree_test.vcproj (contents, props changed)
   trunk/libs/container/proj/vc7ide/vector_test.vcproj (contents, props changed)
   trunk/libs/container/test/ (props changed)
   trunk/libs/container/test/Jamfile.v2 (contents, props changed)
   trunk/libs/container/test/check_equal_containers.hpp (contents, props changed)
   trunk/libs/container/test/deque_test.cpp (contents, props changed)
   trunk/libs/container/test/dummy_test_allocator.hpp (contents, props changed)
   trunk/libs/container/test/emplace_test.hpp (contents, props changed)
   trunk/libs/container/test/expand_bwd_test_allocator.hpp (contents, props changed)
   trunk/libs/container/test/expand_bwd_test_template.hpp (contents, props changed)
   trunk/libs/container/test/flat_tree_test.cpp (contents, props changed)
   trunk/libs/container/test/heap_allocator_v1.hpp (contents, props changed)
   trunk/libs/container/test/list_test.cpp (contents, props changed)
   trunk/libs/container/test/list_test.hpp (contents, props changed)
   trunk/libs/container/test/map_test.hpp (contents, props changed)
   trunk/libs/container/test/movable_int.hpp (contents, props changed)
   trunk/libs/container/test/print_container.hpp (contents, props changed)
   trunk/libs/container/test/set_test.hpp (contents, props changed)
   trunk/libs/container/test/slist_test.cpp (contents, props changed)
   trunk/libs/container/test/stable_vector_test.cpp (contents, props changed)
   trunk/libs/container/test/string_test.cpp (contents, props changed)
   trunk/libs/container/test/tree_test.cpp (contents, props changed)
   trunk/libs/container/test/util.hpp (contents, props changed)
   trunk/libs/container/test/vector_test.cpp (contents, props changed)
   trunk/libs/container/test/vector_test.hpp (contents, props changed)

Added: trunk/libs/container/doc/Jamfile.v2
==============================================================================
--- (empty file)
+++ trunk/libs/container/doc/Jamfile.v2 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,48 @@
+# Boost.Container library documentation Jamfile ---------------------------------
+#
+# Copyright Ion Gaztanaga 2009-2011. Use, modification and
+# distribution is subject to 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)
+#
+# See http://www.boost.org for updates, documentation, and revision history.
+
+import doxygen ;
+import quickbook ;
+
+path-constant images_location : html ;
+
+doxygen autodoc
+ :
+ [ glob ../../../boost/container/*.hpp ]
+ :
+ <doxygen:param>EXTRACT_ALL=NO
+ <doxygen:param>HIDE_UNDOC_MEMBERS=YES
+ <doxygen:param>EXTRACT_PRIVATE=NO
+ <doxygen:param>ENABLE_PREPROCESSING=YES
+ <doxygen:param>EXPAND_ONLY_PREDEF=YES
+ <doxygen:param>MACRO_EXPANSION=YES
+ <doxygen:param>"PREDEFINED=\"insert_const_ref_type= const T&\" \\
+ \"BOOST_CONTAINER_DOXYGEN_INVOKED\" \\
+ \"BOOST_RV_REF(T)=T &&\" \\
+ \"BOOST_COPY_ASSIGN_REF(T)=const T &\" \\
+ \"BOOST_RV_REF_2_TEMPL_ARGS(T,a,b)=T<a, b> &&\" \\
+ \"BOOST_RV_REF_3_TEMPL_ARGS(T,a,b,c)=T<a,b,c>T<a,b,c> &&\" \\
+ \"BOOST_FWD_REF(a)=a &&\""
+ <xsl:param>"boost.doxygen.reftitle=Boost.Container Reference"
+ ;
+
+xml container : container.qbk ;
+
+boostbook standalone
+ :
+ container
+ :
+ <xsl:param>boost.root=../../../..
+ <xsl:param>boost.libraries=../../../../libs/libraries.htm
+ <xsl:param>generate.section.toc.level=3
+ <xsl:param>chunk.first.sections=1
+ <format>pdf:<xsl:param>img.src.path=$(images_location)/
+ <dependency>autodoc
+ <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+ ;

Added: trunk/libs/container/doc/container.qbk
==============================================================================
--- (empty file)
+++ trunk/libs/container/doc/container.qbk 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,580 @@
+[/
+ / Copyright (c) 2009-2011 Ion Gazta\u00F1aga
+ /
+ / 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)
+ /]
+
+[library Boost.Container
+ [quickbook 1.5]
+ [authors [Gaztanaga, Ion]]
+ [copyright 2009-2011 Ion Gaztanaga]
+ [id container]
+ [dirname container]
+ [purpose Containers library]
+ [license
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ [@http://www.boost.org/LICENSE_1_0.txt])
+ ]
+]
+
+[template super[x]'''<superscript>'''[x]'''</superscript>''']
+[template sub[x]'''<subscript>'''[x]'''</subscript>''']
+
+[section:intro Introduction]
+
+[*Boost.Container] library implements several well-known containers, including
+STL containers. The aim of the library is to offers advanced features not present
+in standard containers or to offer the latest standard draft features for compilers
+that comply with C++03.
+
+In short, what does [*Boost.Container] offer?
+
+* Move semantics are implemented, including move emulation for pre-C++11 compilers.
+* New advanced features (e.g. placement insertion, recursive containers) are present.
+* Containers support stateful allocators and are compatible with [*Boost.Interprocess]
+ (they can be safely placed in shared memory).
+* The library offers new useful containers:
+ * [classref boost::container::flat_map flat_map],
+ [classref boost::container::flat_map flat_set],
+ [classref boost::container::flat_map flat_multiset] and
+ [classref boost::container::flat_map flat_multiset]: drop-in
+ replacements for standard associative containers but more memory friendly and with faster
+ searches.
+ * [classref boost::container::stable_vector stable_vector]: a std::list and std::vector hybrid
+ container: vector-like random-access iterators and list-like iterator stability in insertions and erasures.
+ * [classref boost::container::slist slist]: the classic pre-standard singly linked list implementation
+ offering constant-time `size()`. Note that C++11 `forward_list` has no `size()`.
+
+[section:introduction_building_container Building Boost.Container]
+
+There is no need to compile [*Boost.Container], since it's
+a header only library. Just include your Boost header directory in your
+compiler include path.
+
+[endsect]
+
+[section:tested_compilers Tested compilers]
+
+[*Boost.Container] requires a decent C++98 compatibility. Some compilers known to work are:
+
+* Visual C++ >= 7.1.
+* GCC >= 3.4.
+* Intel C++ >= 9.0
+
+[endsect]
+
+[endsect]
+
+[section:move_emplace Efficient insertion]
+
+Move semantics and placement insertion are two features brought by C++11 containers
+that can have a very positive impacto in your C++ applications. Boost.Container implements
+both techniques both for C++11 and C++03 compilers.
+
+[section:move_containers Move-aware containers]
+
+All containers offered by [*Boost.Container] can store movable-only types
+and actual requirements for `value_type` depend on each container operations.
+Following C++11 requirements even for C++03 compilers, many operations now require
+movable or default constructible types instead of just copy constructible types.
+
+Containers themselves are also movable, with no-throw guarantee if allocator
+or predicate (if present) copy operations are no-throw. This allows
+high performance operations when transfering data between vectors.
+Let's see an example:
+
+[import ../example/doc_move_containers.cpp]
+[doc_move_containers]
+
+[endsect]
+
+[section:emplace Emplace: Placement insertion]
+
+All containers offered by [*Boost.Container] implement placement insertion,
+which means that objects can be built directly into the container from user arguments
+without creating any temporary object. For compilers without variadic templates support
+placement insertion is emulated up to a finite (10) number of arguments.
+
+Expensive to move types are perfect candidates emplace functions and in case of node containers
+([classref boost::container::list list], [classref boost::container::set set], ...)
+emplace allows storing non-movable and non-copyable types in containers! Let's
+see an example:
+
+[import ../example/doc_emplace.cpp]
+[doc_emplace]
+
+[endsect]
+
+[endsect]
+
+
+[section:containers_of_incomplete_types Containers of Incomplete Types]
+
+Incomplete types allow
+[@http://en.wikipedia.org/wiki/Type_erasure [*type erasure ]] and
+[@http://en.wikipedia.org/wiki/Recursive_data_type [*recursive data types]], and
+C and C++ programmers have been using it for years to build complex data structures, like
+tree structures where a node may have an arbitrary number of children.
+
+What about standard containers? Containers of incomplete types have been under discussion for a long time,
+as explained in Matt Austern's great article ([@http://drdobbs.com/184403814 [*The Standard Librarian: Containers of Incomplete Types]]):
+
+["['Unlike most of my columns, this one is about something you can't do with the C++ Standard library:
+put incomplete types in one of the standard containers. This column explains why you might want to
+do this, why the standardization committee banned it even though they knew it was useful, and what
+you might be able to do to get around the restriction.]]
+
+["['In 1997, shortly before the C++ Standard was completed, the standardization committee received a
+query: Is it possible to create standard containers with incomplete types? It took a while for the
+committee to understand the question. What would such a thing even mean, and why on earth would you
+ever want to do it? The committee eventually worked it out and came up with an answer to the question.
+(Just so you don't have to skip ahead to the end, the answer is "no.") But the question is much more
+interesting than the answer: it points to a useful, and insufficiently discussed, programming technique.
+The standard library doesn't directly support that technique, but the two can be made to coexist.]]
+
+["['In a future revision of C++, it might make sense to relax the restriction on instantiating
+standard library templates with incomplete types. Clearly, the general prohibition should stay
+in place - instantiating templates with incomplete types is a delicate business, and there are
+too many classes in the standard library where it would make no sense. But perhaps it should be
+relaxed on a case-by-case basis, and `vector` looks like a good candidate for such special-case
+treatment: it's the one standard container class where there are good reasons to instantiate
+it with an incomplete type and where Standard Library implementors want to make it work. As of
+today, in fact, implementors would have to go out of their way to prohibit it!]]
+
+C++11 standard is also cautious about incomplete types and STL: ["['17.6.4.8 Other functions (...) 2.
+the effects are undefined in the following cases: (...) In particular - if an incomplete type (3.9)
+is used as a template argument when instantiating a template component,
+unless specifically allowed for that component]]. Fortunately [*Boost.Container] containers are designed
+to support type erasure and recursive types, so let's see some examples:
+
+[section:recursive_containers Recursive containers]
+
+All containers offered by [*Boost.Container] can be used to define recursive containers:
+
+[import ../example/doc_recursive_containers.cpp]
+[doc_recursive_containers]
+
+[endsect]
+
+[section:type_erasure Type Erasure]
+
+Containers of incomplete types are useful to break header file dependencies and improve
+compilation types. With Boost.Container, you can write a header file defining a class
+with containers of incomplete types as data members, if you carefully put all the
+implementation details that require knowing the size of the `value_type` in your
+implementation file:
+
+[import ../example/doc_type_erasure.cpp]
+
+In this header file we define a class (`MyClassHolder)` that holds a `vector` of an
+incomplete type (`MyClass`) that it's only forward declared.
+
+[doc_type_erasure_MyClassHolder_h]
+
+Then we can define `MyClass` in its own header file.
+
+[doc_type_erasure_MyClass_h]
+
+And include it only in the implementation file of `MyClassHolder`
+
+[doc_type_erasure_MyClassHolder_cpp]
+
+Finally, we can just compile, link, and run!
+
+[doc_type_erasure_main_cpp]
+
+[endsect]
+
+[endsect]
+
+[section:non_standard_containers Non-standard containers]
+
+[section:stable_vector ['stable_vector]]
+
+This useful, fully STL-compliant stable container [@http://bannalia.blogspot.com/2008/09/introducing-stablevector.html designed by by Joaqu\u00EDn M. L\u00F3pez Mu\u00F1oz]
+is an hybrid between `vector` and `list`, providing most of
+the features of `vector` except [@http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69 element contiguity].
+
+Extremely convenient as they are, `vector`s have a limitation that many novice C++ programmers frequently stumble upon:
+iterators and references to an element of an `vector` are invalidated when a preceding element is erased or when the
+vector expands and needs to migrate its internal storage to a wider memory region (i.e. when the required size exceeds
+the vector's capacity). We say then that `vector`s are unstable: by contrast, stable containers are those for which
+references and iterators to a given element remain valid as long as the element is not erased: examples of stable containers
+within the C++ standard library are `list` and the standard associative containers (`set`, `map`, etc.).
+
+Sometimes stability is too precious a feature to live without, but one particular property of `vector`s, element contiguity,
+makes it impossible to add stability to this container. So, provided we sacrifice element contiguity, how much
+can a stable design approach the behavior of `vector` (random access iterators, amortized constant time end
+insertion/deletion, minimal memory overhead, etc.)?
+The following image describes the layout of a possible data structure upon which to base the design of a stable vector:
+
+[$images/stable_vector.png [width 50%] [align center] ]
+
+Each element is stored in its own separate node. All the nodes are referenced from a contiguous array of pointers, but
+also every node contains an "up" pointer referring back to the associated array cell. This up pointer is the key element
+to implementing stability and random accessibility:
+
+Iterators point to the nodes rather than to the pointer array. This ensures stability, as it is only the pointer array
+that needs to be shifted or relocated upon insertion or deletion. Random access operations can be implemented by using
+the pointer array as a convenient intermediate zone. For instance, if the iterator it holds a node pointer `it.p` and we
+want to advance it by n positions, we simply do:
+
+[c++]
+
+ it.p = *(it.p->up+n);
+
+That is, we go "up" to the pointer array, add n there and then go "down" to the resulting node.
+
+[*General properties]. `stable_vector` satisfies all the requirements of a container, a reversible container and a sequence
+and provides all the optional operations present in vector. Like vector, iterators are random access. `stable_vector`
+does not provide element contiguity; in exchange for this absence, the container is stable, i.e. references and iterators
+to an element of a `stable_vector` remain valid as long as the element is not erased, and an iterator that has been
+assigned the return value of end() always remain valid until the destruction of the associated `stable_vector`.
+
+[*Operation complexity]. The big-O complexities of `stable_vector` operations match exactly those of vector. In general,
+insertion/deletion is constant time at the end of the sequence and linear elsewhere. Unlike vector, `stable_vector`
+does not internally perform any value_type destruction, copy/move construction/assignment operations other than those exactly
+corresponding to the insertion of new elements or deletion of stored elements, which can sometimes compensate in terms of
+performance for the extra burden of doing more pointer manipulation and an additional allocation per element.
+
+[*Exception safety]. (according to [@http://www.boost.org/community/exception_safety.html Abrahams' terminology])
+As `stable_vector` does not internally copy/move elements around, some
+operations provide stronger exception safety guarantees than in vector:
+
+[table:stable_vector_req Exception safety
+ [[operation] [exception safety for `vector<T>`] [exception safety for `stable_vector<T>`]]
+ [[insert] [strong unless copy/move construction/assignment of `T` throw (basic)] [strong]]
+ [[erase] [no-throw unless copy/move construction/assignment of `T` throw (basic)] [no-throw]]
+]
+
+[*Memory overhead]. The C++ standard does not specifiy requirements on memory consumption, but virtually any implementation
+of `vector` has the same behavior wih respect to memory usage: the memory allocated by a `vector` v with n elements of type T
+is
+
+m[sub v] = c\u2219e,
+
+where c is `v.capacity()` and e is `sizeof(T)`. c can be as low as n if the user has explicitly reserved the exact capacity
+required; otherwise, the average value c for a growing `vector` oscillates between 1.25\u2219n and 1.5\u2219n for typical resizing
+policies. For `stable_vector`, the memory usage is
+
+m[sub sv] = (c + 1)p + (n + 1)(e + p),
+
+where p is the size of a pointer. We have c + 1 and n + 1 rather than c and n because a dummy node is needed at the end of
+the sequence. If we call f the capacity to size ratio c/n and assume that n is large enough, we have that
+
+m[sub sv]/m[sub v] \u2243 (fp + e + p)/fe.
+
+So, `stable_vector` uses less memory than `vector` only when e > p and the capacity to size ratio exceeds a given threshold:
+
+m[sub sv] < m[sub v] <-> f > (e + p)/(e - p). (provided e > p)
+
+This threshold approaches typical values of f below 1.5 when e > 5p; in a 32-bit architecture, when e > 20 bytes.
+
+[*Summary]. `stable_vector` is a drop-in replacement for `vector` providing stability of references and iterators, in exchange
+for missing element contiguity and also some performance and memory overhead. When the element objects are expensive to
+move around, the performance overhead can turn into a net performance gain for `stable_vector` if many middle insertions
+or deletions are performed or if resizing is very frequent. Similarly, if the elements are large there are situations when
+the memory used by `stable_vector` can actually be less than required by vector.
+
+['Note: Text and explanations taken from [@http://bannalia.blogspot.com/2008/09/introducing-stablevector.html Joaqu\u00EDn's blog]]
+
+[endsect]
+
+[section:flat_xxx ['flat_(multi)map/set] associative containers]
+
+Using sorted vectors instead of tree-based associative containers is a well-known technique in
+C++ world. Matt Austern's classic article
+[@http://lafstern.org/matt/col1.pdf Why You Shouldn't Use set, and What You Should Use Instead]
+(C++ Report 12:4, April 2000) was enlightening:
+
+["['Red-black trees aren't the only way to organize data that permits lookup in logarithmic time. One of the basic
+algorithms of computer science is binary search, which works by successively dividing a range in half. Binary
+search is log N and it doesn't require any fancy data structures, just a sorted collection of elements.
+(...) You can use whatever data structure is convenient, so long as it provides STL iterator;
+usually it's easiest to use a C array, or a vector.]]
+
+["['Both std::lower_bound and set::find take time proportional to log N, but the constants of proportionality
+are very different. Using g++ (...) it takes X seconds to perform a million lookups in a
+sorted vector<double> of a million elements, and almost twice as long (...) using a set. Moreover,
+the set uses almost three times as much memory (48 million bytes) as the vector (16.8 million).]]
+
+["['Using a sorted vector instead of a set gives you faster lookup and much faster iteration,
+but at the cost of slower insertion. Insertion into a set, using set::insert, is proportional
+to log N, but insertion into a sorted vector, (...)
+, is proportional to N. Whenever you insert something into a vector,
+vector::insert has to make room by shifting all of the elements that follow it. On average, if you're equally
+likely to insert a new element anywhere, you'll be shifting N/2 elements.]]
+
+["['It may sometimes be convenient to bundle all of this together into a small container adaptor.
+This class does not satisfy the requirements of a Standard Associative Container, since the complexity of insert is
+O(N) rather than O(log N), but otherwise it is almost a drop-in replacement for set.]]
+
+Following Matt Austerns indications, Andrei Alexandrescu's
+[@http://www.bestwebbuys.com/Modern-C-Design-Generic-Programming-and-Design-Patterns-Applied-ISBN-9780201704310?isrc=-rd Modern C++ Design]
+showed `AssocVector`, a `std::map` drop-in
+replacement designed in his [@http://loki-lib.sourceforge.net/ Loki] library:
+
+["['It seems as if we're better off with a sorted vector. The disadvantages of a sorted
+vector are linear-time insertions and linear-time deletions (...). In exchange, a vector
+offers about twice the lookup speed and a much smaller working set (...).
+Loki saves the trouble of maintaining a sorted vector by hand by defining an AssocVector class
+template. AssocVector is a drop-in replacement for std::map (it supports the same set of member
+functions), implemented on top of std::vector. AssocVector differs from a map in the behavior of
+its erase functions (AssocVector::erase invalidates all iterators into the object) and in the
+complexity guarantees of insert and erase (linear as opposed to constant). ]]
+
+[*Boost.Container] `flat_[multi]map/set` containers are ordered-vector based associative containers
+based on Austern's and Alexandrescu's guidelines. These ordered vector containers have also
+benefited recently with the addition of `move semantics` to C++, speeding up insertion
+and erasure times considerably. Flat associative containers have the following
+attributes:
+
+* Faster lookup than standard associative containers
+* Much faster iteration than standard associative containers
+* Less memory consumption for small objects (and for big objects if `shrink_to_fit` is used)
+* Improved cache performance (data is stored in contiguous memory)
+* Non-stable iterators (iterators are invalidated when inserting and erasing elements)
+* Non-copyable and non-movable values types can't be stored
+* Weaker exception safety than standard associative containers
+(copy/move constructors can throw when shifting values in erasures and insertions)
+* Slower insertion and erasure than standard associative containers (specially for non-movable types)
+
+[endsect]
+
+[section:slist ['slist]]
+
+When the standard template library was designed, it contained a singly linked list called `slist`.
+Unfortunately, this container was not standardized and remained as an extension for many standard
+library implementations until C++11 introduced `forward_list`, which is a bit different from the
+the original SGI `slist`. According to [@http://www.sgi.com/tech/stl/Slist.html SGI STL documentation]:
+
+["['An `slist` is a singly linked list: a list where each element is linked to the next element, but
+not to the previous element. That is, it is a Sequence that supports forward but not backward traversal,
+and (amortized) constant time insertion and removal of elements. Slists, like lists, have the important
+property that insertion and splicing do not invalidate iterators to list elements, and that even removal
+invalidates only the iterators that point to the elements that are removed. The ordering of iterators
+may be changed (that is, slist<T>::iterator might have a different predecessor or successor after a list
+operation than it did before), but the iterators themselves will not be invalidated or made to point to
+different elements unless that invalidation or mutation is explicit.]]
+
+["['The main difference between `slist` and list is that list's iterators are bidirectional iterators,
+while slist's iterators are forward iterators. This means that `slist` is less versatile than list;
+frequently, however, bidirectional iterators are unnecessary. You should usually use `slist` unless
+you actually need the extra functionality of list, because singly linked lists are smaller and faster
+than double linked lists.]]
+
+["['Important performance note: like every other Sequence, `slist` defines the member functions insert and erase.
+Using these member functions carelessly, however, can result in disastrously slow programs. The problem is that
+insert's first argument is an iterator pos, and that it inserts the new element(s) before pos. This means that
+insert must find the iterator just before pos; this is a constant-time operation for list, since list has
+bidirectional iterators, but for `slist` it must find that iterator by traversing the list from the beginning
+up to pos. In other words: insert and erase are slow operations anywhere but near the beginning of the slist.]]
+
+["['Slist provides the member functions insert_after and erase_after, which are constant time operations: you should
+always use insert_after and erase_after whenever possible. If you find that insert_after and erase_after aren't
+adequate for your needs, and that you often need to use insert and erase in the middle of the list, then you
+should probably use list instead of slist.]]
+
+[*Boost.Container] updates the classic `slist` container with C++11 features like move semantics and placement
+insertion and implements it a bit differently for the standard C++11 `forward_list`. `forward_list` has no `size()`
+method, so it's been designed to allow (or in practice, encourage) implementations without tracking list size
+with every insertion/erasure, allowing constant-time
+`splice_after(iterator, forward_list &, iterator, iterator)`-based list merging. On the other hand `slist` offers
+constant-time `size()` for those that don't care about linear-time `splice_after(iterator, slist &, iterator, iterator)`
+`size()` and offers an additional `splice_after(iterator, slist &, iterator, iterator, size_type)` method that
+can speed up `slist` merging when the programmer already knows the size. `slist` and `forward_list` are therefore
+complementary.
+
+[endsect]
+
+[endsect]
+
+[section:Cpp11_conformance C++11 Conformance]
+
+[*Boost.Container] aims for full C++11 conformance except reasoned deviations,
+backporting as much as possible for C++03. Obviously, this conformance is a work
+in progress so this section explains what C++11 features are implemented and which of them
+have been backported to C++03 compilers.
+
+[section:move_emplace Move and Emplace]
+
+For compilers with rvalue references and for those C++03 types that use
+[@http://www.boost.org/libs/move Boost.Move] rvalue reference emulation
+[*Boost.Container] supports all C++11 features related to move semantics: containers
+are movable, requirements for `value_type` are those specified for C++11 containers.
+
+For compilers with variadic templates, [*Boost.Container] supports placement insertion
+(`emplace`, ...) functions from C++11. For those compilers without variadic templates
+support [*Boost.Container] uses the preprocessor to create a set of overloads up to
+a finite (10) number of parameters.
+
+[endsect]
+
+[section:alloc_traits_move_traits Stateful allocators and Scoped allocators]
+
+C++03 was not stateful-allocator friendly. For compactness of container objects and for
+simplicity, it did not require containers to support allocators with state: Allocator objects
+need not be stored in container objects. It was not possible to store an allocator with state,
+say an allocator that holds a pointer to an arena from which to allocate. C++03 allowed implementors
+to suppose two allocators of the same type always compare equal (that means that memory allocated
+by one allocator object could be deallocated by another instance of the same type) and
+allocators were not swapped when the container was swapped.
+
+Many C++ container implementors felt C++03 guarantees were too weak and started to offer extensions.
+[*Boost.Container], following [@http://www.boost.org/libs/interprocess/ Boost.Interprocess]
+containers experience supporting stateful allocators, offers the following guarantees:
+
+* Allocators are copy-constructed in copy/move constructors
+* If possible, asingle allocator is hold to construct `value_type` and this allocator is copy constructed
+ from the user-supplied allocator object during container's contructor. If the container needs an auxiliary
+ allocator (e.g. a array allocator used by `deque` or `stable_vector`), that allocator is also
+ copy-constructed from the user-supplied allocator when the container is constructed (i.e. it's
+ not constructed on the fly when auxiliary memory is needed).
+* Allocators are compared for equality when swapping containers. If allocators dont' compare
+ equal allocators are swapped using an unqualified `swap` call.
+
+C++11 further improves stateful allocator support through the
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2554.pdf
+Scoped Allocators model], using classes like `std::scoped_allocator_adaptor` and `std::allocator_traits`.
+[*Boost.Container does not support it yet, but there are plans to do so and backport scoped allocator
+support to C++03 compilers.
+
+[endsect]
+
+[section:initializer_lists Initializer lists]
+
+[*Boost.Container] does not support initializer lists when constructing or assigning containers
+but it will support it for compilers with initialized-list support. This feature won't be backported
+to C++03 compilers.
+
+[endsect]
+
+[section:Vector_bool vector<bool>]
+
+`vector<bool>` specialization has been quite problematic, and there have been several
+unsuccessful tries to deprecate or remove it from the standard. [*Boost.Container] does not implement it
+as there is a superior [@http://www.boost.org/libs/dynamic_bitset/ Boost.DynamicBitset]
+solution. For issues with `vector<bool>` see papers
+[@http://www.gotw.ca/publications/N1211.pdf vector<bool>: N1211: More Problems, Better Solutions],
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2160.html N2160: Library Issue 96: Fixing vector<bool>],
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2204.html N2204 A Specification to deprecate vector<bool>].
+
+* ["['In 1998, admitting that the committee made a mistake was controversial.
+ Since then Java has had to deprecate such significant portions of their libraries
+ that the idea C++ would be ridiculed for deprecating a single minor template specialization seems quaint.]]
+
+* ["['`vector<bool>` is not a container and `vector<bool>::iterator` is not a random-access iterator
+(or even a forward or bidirectional iterator either, for that matter). This has already broken user code
+in the field in mysterious ways.]]
+
+* ["['`vector<bool>` forces a specific (and potentially bad) optimization choice on all users by enshrining
+it in the standard. The optimization is premature; different users have different requirements. This too
+has already hurt users who have been forced to implement workarounds to disable the 'optimization'
+(e.g., by using a vector<char> and manually casting to/from bool).]]
+
+So `boost::container::vector<bool>::iterator` returns real `bool` references and works as a fully compliant container.
+If you need a memory optimized version of `boost::container::vector<bool>` functionalities, please use
+[@http://www.boost.org/libs/dynamic_bitset/ Boost.DynamicBitset].
+
+[endsect]
+
+[endsect]
+
+[section:other_features Other features]
+
+* Default constructors don't allocate memory which improves performance and
+ usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw).
+
+* Small string optimization for [classref boost::container::basic_string basic_string],
+ with an internal buffer of 11/23 bytes (32/64 bit systems)
+ [*without] increasing the usual `sizeof` of the string (3 words).
+
+* `[multi]set/map` containers are size optimized embedding the color bit of the red-black trees into
+ the parent pointer.
+
+* `[multi]set/map` containers use no recursive functions so stack problems are avoided.
+
+[endsect]
+
+[section:history_and_reasons History and reasons to use Boost.Container]
+
+[section:boost_container_history Boost.Container history]
+
+[*Boost.Container] is a product of a long development effort that started with the experimental Shmem library,
+which pioneered the use of standard containers in shared memory. Shmem included modified SGI STL container
+code tweaked to support non-raw `allocator::pointer` types and stateful allocators. Once reviewed,
+Shmem was accepted as [@http://www.boost.org/libs/interprocess/ Boost.Interprocess] and this library
+continued to refine and improve those containers.
+
+In 2007, container code from node containers (`map`, `list`, `slist`) was rewritten, refactored
+and expanded to build the intrusive container library [@http://www.boost.org/libs/intrusive/ Boost.Intrusive].
+[*Boost.Interprocess] containers were refactored to take advantage of [*Boost.Intrusive] containers and
+code duplication was minimized. Both libraries continued to gain support and bug fixes for years.
+They introduced move semantics, emplacement insertion and more features of then unreleased C++0x
+standard.
+
+[*Boost.Interprocess] containers were always standard compliant, and those containers and new
+containers like `stable_vector` and `flat_[multi]set/map` were used outside [*Boost.Interprocess]
+with success. As containers were mature enough to get their own library, it was a natural step to
+collect them containers and build [*Boost.Container], a library targeted to a wider audience.
+
+[endsect]
+
+
+[section:Why_boost_container Why Boost.Container?]
+
+With so many high quality standard library implemenations out there, why would you want to
+use [*Boost.Container]? There are several reasons for that:
+
+* If you have a C++03 compiler, you can have access to C++11 features and have an easy
+ code migration when you change your compiler.
+* It's compatible with [*Boost.Interprocess] shared memory allocators.
+* You have extremely useful new containers like `stable_vector` and `flat_[multi]set/map`.
+* If you work on multiple plataforms, you'll have a portable behaviour without depending
+ on the std-lib implementation conformance of each platform. Some examples:
+ * Default constructors don't allocate memory at all, which improves performance and
+ usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw).
+ * Small string optimization for [classref boost::container::basic_string basic_string].
+* New extensions beyond the standard based on user feedbak to improve code performance.
+
+[endsect]
+
+[endsect]
+
+
+
+
+[section:acknowledgements_notes Acknowledgements, notes and links]
+
+* Original standard container code comes from [@http://www.sgi.com/tech/stl/ SGI STL library],
+ which enhanced the original HP STL code. Most of this code was rewritten for
+ [*Boost.Interprocess] and moved to [*Boost.Intrusive]. `deque` and `string` containers still
+ have fragments of the original SGI code. Many thanks to Alexander Stepanov, Meng Lee, and David Musser,
+ Matt Austern, and all HP and SGI STL developers.
+
+* `flat_[multi]_map/set` containers were originally based on [@http://en.wikipedia.org/wiki/Loki_%28C%2B%2B%29 Loki's]
+ AssocVector class. Code was rewritten and expanded for [*Boost.Interprocess], so thanks to Andrei Alexandrescu.
+
+* `stable_vector` was invented and coded by
+ [@http://bannalia.blogspot.com/2008/09/introducing-stablevector.html Joaqu\u00EDn M. L\u00F3pez Mu\u00F1oz],
+ then adapted for [*Boost.Interprocess]. Thanks for such a great container.
+
+* Howard Hinnant's help and experience was essential when implementing move semantics,
+ improving allocator support and implementing small string optimization. Thanks Howard
+ for your wonderful standard library implementations.
+
+* And finally thanks to all Boosters who helped all these years, improving, fixing and
+ reviewing the library.
+
+[endsect]
+
+[section:release_notes Release Notes]
+
+* First release with Boost 1.48. Container code from [*Boost.Interprocess] was deleted
+ and redirected to [*Boost.Container ] via using directives.
+
+[endsect]
+
+[xinclude autodoc.xml]

Added: trunk/libs/container/doc/html/boostbook.css
==============================================================================
--- (empty file)
+++ trunk/libs/container/doc/html/boostbook.css 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,537 @@
+/*=============================================================================
+ Copyright (c) 2004 Joel de Guzman
+
+ Use, modification and distribution is subject to 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)
+=============================================================================*/
+
+/*=============================================================================
+ Body defaults
+=============================================================================*/
+
+ body
+ {
+ margin: 1em;
+ font-family: sans-serif;
+ }
+
+/*=============================================================================
+ Paragraphs
+=============================================================================*/
+
+ p
+ {
+ text-align: left;
+ font-size: 10pt;
+ line-height: 1.15;
+ }
+
+/*=============================================================================
+ Program listings
+=============================================================================*/
+
+ /* Code on paragraphs */
+ p tt.computeroutput
+ {
+ font-size: 10pt;
+ }
+
+ pre.synopsis
+ {
+ font-size: 10pt;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ .programlisting,
+ .screen
+ {
+ font-size: 10pt;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+/*=============================================================================
+ Headings
+=============================================================================*/
+
+ h1, h2, h3, h4, h5, h6
+ {
+ text-align: left;
+ margin: 1em 0em 0.5em 0em;
+ font-weight: bold;
+ }
+
+ h1 { font: 140% }
+ h2 { font: bold 140% }
+ h3 { font: bold 130% }
+ h4 { font: bold 120% }
+ h5 { font: italic 110% }
+ h6 { font: italic 100% }
+
+ /* Top page titles */
+ title,
+ h1.title,
+ h2.title
+ h3.title,
+ h4.title,
+ h5.title,
+ h6.title,
+ .refentrytitle
+ {
+ font-weight: bold;
+ margin-bottom: 1pc;
+ }
+
+ h1.title { font-size: 140% }
+ h2.title { font-size: 140% }
+ h3.title { font-size: 130% }
+ h4.title { font-size: 120% }
+ h5.title { font-size: 110% }
+ h6.title { font-size: 100% }
+
+ .section h1
+ {
+ margin: 0em 0em 0.5em 0em;
+ font-size: 140%;
+ }
+
+ .section h2 { font-size: 140% }
+ .section h3 { font-size: 130% }
+ .section h4 { font-size: 120% }
+ .section h5 { font-size: 110% }
+ .section h6 { font-size: 100% }
+
+ /* Code on titles */
+ h1 tt.computeroutput { font-size: 140% }
+ h2 tt.computeroutput { font-size: 140% }
+ h3 tt.computeroutput { font-size: 130% }
+ h4 tt.computeroutput { font-size: 120% }
+ h5 tt.computeroutput { font-size: 110% }
+ h6 tt.computeroutput { font-size: 100% }
+
+/*=============================================================================
+ Author
+=============================================================================*/
+
+ h3.author
+ {
+ font-size: 100%
+ }
+
+/*=============================================================================
+ Lists
+=============================================================================*/
+
+ li
+ {
+ font-size: 10pt;
+ line-height: 1.3;
+ }
+
+ /* Unordered lists */
+ ul
+ {
+ text-align: left;
+ }
+
+ /* Ordered lists */
+ ol
+ {
+ text-align: left;
+ }
+
+/*=============================================================================
+ Links
+=============================================================================*/
+
+ a
+ {
+ text-decoration: none; /* no underline */
+ }
+
+ a:hover
+ {
+ text-decoration: underline;
+ }
+
+/*=============================================================================
+ Spirit style navigation
+=============================================================================*/
+
+ .spirit-nav
+ {
+ text-align: right;
+ }
+
+ .spirit-nav a
+ {
+ color: white;
+ padding-left: 0.5em;
+ }
+
+ .spirit-nav img
+ {
+ border-width: 0px;
+ }
+
+/*=============================================================================
+ Table of contents
+=============================================================================*/
+
+ .toc
+ {
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.1pc 1pc 0.1pc 1pc;
+ font-size: 10pt;
+ line-height: 1.15;
+ }
+
+ .toc-main
+ {
+ width: 600;
+ text-align: center;
+ margin: 1pc 1pc 1pc 10%;
+ padding: 2pc 1pc 3pc 1pc;
+ line-height: 0.1;
+ }
+
+ .boost-toc
+ {
+ float: right;
+ padding: 0.5pc;
+ }
+
+/*=============================================================================
+ Tables
+=============================================================================*/
+
+ .table-title,
+ div.table p.title
+ {
+ margin-left: 4%;
+ padding-right: 0.5em;
+ padding-left: 0.5em;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ width: 92%;
+ margin-left: 4%;
+ margin-right: 4%;
+ }
+
+ div.informaltable table,
+ div.table table
+ {
+ padding: 4px;
+ }
+
+ /* Table Cells */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ padding: 0.5em;
+ text-align: left;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ padding: 0.5em 0.5em 0.5em 0.5em;
+ border: 1pt solid white;
+ font-size: 120%;
+ }
+
+/*=============================================================================
+ Blurbs
+=============================================================================*/
+
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ font-size: 10pt;
+ line-height: 1.2;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ p.blurb img
+ {
+ padding: 1pt;
+ }
+
+/*=============================================================================
+ Variable Lists
+=============================================================================*/
+
+ span.term
+ {
+ font-weight: bold;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td
+ {
+ text-align: left;
+ vertical-align: top;
+ padding: 0em 2em 0em 0em;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td p
+ {
+ margin: 0em 0em 0.5em 0em;
+ }
+
+ /* Make the terms in definition lists bold */
+ div.variablelist dl dt
+ {
+ font-weight: bold;
+ font-size: 10pt;
+ }
+
+ div.variablelist dl dd
+ {
+ margin: 1em 0em 1em 2em;
+ font-size: 10pt;
+ }
+
+/*=============================================================================
+ Misc
+=============================================================================*/
+
+ /* Title of books and articles in bibliographies */
+ span.title
+ {
+ font-style: italic;
+ }
+
+ span.underline
+ {
+ text-decoration: underline;
+ }
+
+ span.strikethrough
+ {
+ text-decoration: line-through;
+ }
+
+ /* Copyright, Legal Notice */
+ div div.legalnotice p
+ {
+ font-size: 8pt;
+ text-align: left
+ }
+
+/*=============================================================================
+ Colors
+=============================================================================*/
+
+ @media screen
+ {
+ /* Links */
+ a
+ {
+ color: #0C7445;
+ }
+
+ a:visited
+ {
+ color: #663974;
+ }
+
+ h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+ h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+ h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+ {
+ text-decoration: none; /* no underline */
+ color: #000000;
+ }
+
+ /* Syntax Highlighting */
+ .keyword { color: #0000AA; }
+ .identifier { color: #000000; }
+ .special { color: #707070; }
+ .preprocessor { color: #402080; }
+ .char { color: teal; }
+ .comment { color: #800000; }
+ .string { color: teal; }
+ .number { color: teal; }
+ .white_bkd { background-color: #E8FBE9; }
+ .dk_grey_bkd { background-color: #A0DAAC; }
+
+ /* Copyright, Legal Notice */
+ .copyright
+ {
+ color: #666666;
+ font-size: small;
+ }
+
+ div div.legalnotice p
+ {
+ color: #666666;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Blurbs */
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc-main
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid #DCDCDC;
+ background-color: #FAFFFB;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ background-color: #E3F9E4;
+ border: 1px solid #DCDCDC;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ color: #00A000;
+ }
+ }
+
+ @media print
+ {
+ /* Links */
+ a
+ {
+ color: black;
+ }
+
+ a:visited
+ {
+ color: black;
+ }
+
+ .spirit-nav
+ {
+ display: none;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid gray;
+ background-color: #FAFFFB;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid gray;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc-main
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ border-collapse: collapse;
+ background-color: #FAFFFB;
+ }
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid #DCDCDC;
+ background-color: #FAFFFB;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ border: 1px solid #DCDCDC;
+ background-color: #FAFFFB;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ font-weight: bold;
+ }
+ }

Added: trunk/libs/container/doc/html/images/blank.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/caution.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/draft.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/home.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/important.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/next.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/note.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/prev.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/stable_vector.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/tip.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/toc-blank.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/toc-minus.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/toc-plus.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/up.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/images/warning.png
==============================================================================
Binary file. No diff available.

Added: trunk/libs/container/doc/html/index.html
==============================================================================
--- (empty file)
+++ trunk/libs/container/doc/html/index.html 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,110 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter&#160;1.&#160;Boost.Container</title>
+<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.67.0">
+<link rel="start" href="index.html" title="Chapter&#160;1.&#160;Boost.Container">
+<link rel="next" href="container/intro.html" title="Introduction">
+</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 align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="container/intro.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="chapter" lang="en">
+<div class="titlepage"><div>
+<div><h2 class="title">
+<a name="container"></a>Chapter&#160;1.&#160;Boost.Container</h2></div>
+<div><div class="author"><h3 class="author">
+<span class="firstname">Ion</span> <span class="surname">Gaztanaga</span>
+</h3></div></div>
+<div><p class="copyright">Copyright &#169; 2009-2011 Ion Gaztanaga</p></div>
+<div><div class="legalnotice">
+<a name="id706806"></a><p>
+ 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)
+ </p>
+</div></div>
+</div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section">Introduction</span></dt>
+<dd><dl>
+<dt><span class="section"><a href="container/intro.html#container.intro.introduction_building_container">Building
+ Boost.Container</a></span></dt>
+<dt><span class="section">Tested compilers</span></dt>
+</dl></dd>
+<dt><span class="section">Efficient insertion</span></dt>
+<dd><dl>
+<dt><span class="section">Move-aware containers</span></dt>
+<dt><span class="section">Emplace: Placement insertion</span></dt>
+</dl></dd>
+<dt><span class="section"><a href="container/containers_of_incomplete_types.html">Containers of
+ Incomplete Types</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="container/containers_of_incomplete_types.html#container.containers_of_incomplete_types.recursive_containers">Recursive
+ containers</a></span></dt>
+<dt><span class="section"><a href="container/containers_of_incomplete_types.html#container.containers_of_incomplete_types.type_erasure">Type
+ Erasure</a></span></dt>
+</dl></dd>
+<dt><span class="section">Non-standard containers</span></dt>
+<dd><dl>
+<dt><span class="section">stable_vector</span></dt>
+<dt><span class="section"><a href="container/non_standard_containers.html#container.non_standard_containers.flat_xxx"><span class="emphasis"><em>flat_(multi)map/set</em></span>
+ associative containers</a></span></dt>
+<dt><span class="section">slist</span></dt>
+</dl></dd>
+<dt><span class="section">C++11 Conformance</span></dt>
+<dd><dl>
+<dt><span class="section">Move and Emplace</span></dt>
+<dt><span class="section"><a href="container/Cpp11_conformance.html#container.Cpp11_conformance.alloc_traits_move_traits">Stateful
+ allocators and Scoped allocators</a></span></dt>
+<dt><span class="section"><a href="container/Cpp11_conformance.html#container.Cpp11_conformance.initializer_lists">Initializer
+ lists</a></span></dt>
+<dt><span class="section">vector<bool></span></dt>
+</dl></dd>
+<dt><span class="section">Other features</span></dt>
+<dt><span class="section"><a href="container/history_and_reasons.html">History and reasons to use
+ Boost.Container</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="container/history_and_reasons.html#container.history_and_reasons.boost_container_history">Boost.Container
+ history</a></span></dt>
+<dt><span class="section"><a href="container/history_and_reasons.html#container.history_and_reasons.Why_boost_container">Why
+ Boost.Container?</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="container/acknowledgements_notes.html">Acknowledgements, notes
+ and links</a></span></dt>
+<dt><span class="section">Release Notes</span></dt>
+<dt><span class="section">Boost.Container Reference</span></dt>
+<dd><dl>
+<dt><span class="section">Header <boost/container/container_fwd.hpp></span></dt>
+<dt><span class="section">Header <boost/container/deque.hpp></span></dt>
+<dt><span class="section">Header <boost/container/flat_map.hpp></span></dt>
+<dt><span class="section">Header <boost/container/flat_set.hpp></span></dt>
+<dt><span class="section">Header <boost/container/list.hpp></span></dt>
+<dt><span class="section">Header <boost/container/map.hpp></span></dt>
+<dt><span class="section">Header <boost/container/set.hpp></span></dt>
+<dt><span class="section">Header <boost/container/slist.hpp></span></dt>
+<dt><span class="section">Header <boost/container/stable_vector.hpp></span></dt>
+<dt><span class="section">Header <boost/container/string.hpp></span></dt>
+<dt><span class="section">Header <boost/container/vector.hpp></span></dt>
+</dl></dd>
+</dl>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: August 26, 2011 at 17:45:38 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="container/intro.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+</body>
+</html>

Added: trunk/libs/container/doc/html/reference.css
==============================================================================
--- (empty file)
+++ trunk/libs/container/doc/html/reference.css 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,12 @@
+/*=============================================================================
+ Copyright (c) 2004 Joel de Guzman
+
+ Use, modification and distribution is subject to 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)
+=============================================================================*/
+PRE.synopsis {
+ background-color: #e0ffff;
+ border: thin solid blue;
+ padding: 1em
+}

Added: trunk/libs/container/example/Jamfile.v2
==============================================================================
--- (empty file)
+++ trunk/libs/container/example/Jamfile.v2 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,34 @@
+# Boost Container Library Example Jamfile
+
+# (C) Copyright Ion Gaztanaga 2009
+# Use, modification and distribution are subject to 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)
+
+# Adapted from John Maddock's TR1 Jamfile.v2
+# Copyright John Maddock 2005.
+# Use, modification and distribution are subject to 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)
+
+# this rule enumerates through all the sources and invokes
+# the run rule for each source, the result is a list of all
+# the run rules, which we can pass on to the test_suite rule:
+
+rule test_all
+{
+ local all_rules = ;
+
+ for local fileb in [ glob doc_*.cpp ]
+ {
+ all_rules += [ run $(fileb)
+ : # additional args
+ : # test-files
+ : # requirements
+ ] ;
+ }
+
+ return $(all_rules) ;
+}
+
+test-suite container_example : [ test_all r ] : <threading>multi ;
\ No newline at end of file

Added: trunk/libs/container/example/doc_emplace.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/example/doc_emplace.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_emplace
+#include <boost/container/list.hpp>
+#include <cassert>
+
+//Non-copyable and non-movable class
+class non_copy_movable
+{
+ non_copy_movable(const non_copy_movable &);
+ non_copy_movable& operator=(const non_copy_movable &);
+
+ public:
+ non_copy_movable(int = 0) {}
+};
+
+int main ()
+{
+ using namespace boost::container;
+
+ //Store non-copyable and non-movable objects in a list
+ list<non_copy_movable> l;
+ non_copy_movable ncm;
+
+ //A new element will be built calling non_copy_movable(int) contructor
+ l.emplace(l.begin(), 0);
+ assert(l.size() == 1);
+
+ //A new element will be built calling the default constructor
+ l.emplace(l.begin());
+ assert(l.size() == 2);
+ return 0;
+}
+//]
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/example/doc_move_containers.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/example/doc_move_containers.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,54 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_move_containers
+#include <boost/container/vector.hpp>
+#include <boost/move/move.hpp>
+#include <cassert>
+
+//Non-copyable class
+class non_copyable
+{
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(non_copyable)
+
+ public:
+ non_copyable(){}
+ non_copyable(BOOST_RV_REF(non_copyable)) {}
+ non_copyable& operator=(BOOST_RV_REF(non_copyable)) { return *this; }
+};
+
+int main ()
+{
+ using namespace boost::container;
+
+ //Store non-copyable objects in a vector
+ vector<non_copyable> v;
+ non_copyable nc;
+ v.push_back(boost::move(nc));
+ assert(v.size() == 1);
+
+ //Reserve no longer needs copy-constructible
+ v.reserve(100);
+ assert(v.capacity() >= 100);
+
+ //This resize overload only needs movable and default constructible
+ v.resize(200);
+ assert(v.size() == 200);
+
+ //Containers are also movable
+ vector<non_copyable> v_other(boost::move(v));
+ assert(v_other.size() == 200);
+ assert(v.empty());
+
+ return 0;
+}
+//]
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/example/doc_recursive_containers.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/example/doc_recursive_containers.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,61 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_recursive_containers
+#include <boost/container/vector.hpp>
+#include <boost/container/list.hpp>
+#include <boost/container/map.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/string.hpp>
+
+using namespace boost::container;
+
+struct data
+{
+ int i_;
+ //A vector holding still undefined class 'data'
+ vector<data> v_;
+ //A list holding still undefined 'data'
+ list<data> l_;
+ //A map holding still undefined 'data'
+ map<data, data> m_;
+
+ friend bool operator <(const data &l, const data &r)
+ { return l.i_ < r.i_; }
+};
+
+struct tree_node
+{
+ string name;
+ string value;
+
+ //children nodes of this node
+ list<tree_node> children_;
+};
+
+
+
+int main()
+{
+ //a container holding a recursive data type
+ stable_vector<data> sv;
+ sv.resize(100);
+
+ //Let's build a tree based in
+ //a recursive data type
+ tree_node root;
+ root.name = "root";
+ root.value = "root_value";
+ root.children_.resize(7);
+ return 0;
+}
+//]
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/example/doc_type_erasure.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/example/doc_type_erasure.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,91 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_type_erasure_MyClassHolder_h
+#include <boost/container/vector.hpp>
+
+//MyClassHolder.h
+
+//We don't need to include "MyClass.h"
+//to store vector<MyClass>
+class MyClass;
+
+class MyClassHolder
+{
+ public:
+
+ void AddNewObject(const MyClass &o);
+ const MyClass & GetLastObject() const;
+
+ private:
+ ::boost::container::vector<MyClass> vector_;
+};
+
+//]
+
+//[doc_type_erasure_MyClass_h
+
+//MyClass.h
+
+class MyClass
+{
+ private:
+ int value_;
+
+ public:
+ MyClass(int val = 0) : value_(val){}
+
+ friend bool operator==(const MyClass &l, const MyClass &r)
+ { return l.value_ == r.value_; }
+ //...
+};
+
+//]
+
+
+
+//[doc_type_erasure_main_cpp
+
+//Main.cpp
+
+//=#include "MyClassHolder.h"
+//=#include "MyClass.h"
+
+#include <cassert>
+
+int main()
+{
+ MyClass mc(7);
+ MyClassHolder myclassholder;
+ myclassholder.AddNewObject(mc);
+ return myclassholder.GetLastObject() == mc ? 0 : 1;
+}
+//]
+
+//[doc_type_erasure_MyClassHolder_cpp
+
+//MyClassHolder.cpp
+
+//=#include "MyClassHolder.h"
+
+//In the implementation MyClass must be a complete
+//type so we include the appropriate header
+//=#include "MyClass.h"
+
+void MyClassHolder::AddNewObject(const MyClass &o)
+{ vector_.push_back(o); }
+
+const MyClass & MyClassHolder::GetLastObject() const
+{ return vector_.back(); }
+
+//]
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/index.html
==============================================================================
--- (empty file)
+++ trunk/libs/container/index.html 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,14 @@
+<!--
+Copyright 2005-2011 Ion Gaztanaga
+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)
+-->
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/container.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+../../doc/html/container.html
+</body>
+</html>

Added: trunk/libs/container/proj/to-do.txt
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/to-do.txt 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,2 @@
+->Change "insert" and "push_back"/"push_front" to catch non-const rvalues
+->Add an example with stateful allocators

Added: trunk/libs/container/proj/vc7ide/container.sln
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/container.sln 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,87 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "deque_test", "deque_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792655}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "flat_tree_test", "flat_tree_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792637}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "list_test", "list_ex.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792632}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "stable_vector_test", "stable_vector_test.vcproj", "{5E11C8D3-FA52-760A-84FE-943A6BA05A21}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "string_test", "string_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D4A792607}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tree_test", "tree_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792606}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slist_test", "slist_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792608}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vector_test", "vector_test.vcproj", "{5CE11C83-096A-84FE-4FA2-D3A6BA792002}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_containerlib", "container.vcproj", "{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}"
+ ProjectSection(ProjectDependencies) = postProject
+ EndProjectSection
+EndProject
+Global
+ GlobalSection(SolutionConfiguration) = preSolution
+ Debug = Debug
+ Release = Release
+ EndGlobalSection
+ GlobalSection(ProjectDependencies) = postSolution
+ EndGlobalSection
+ GlobalSection(ProjectConfiguration) = postSolution
+ {58CCE183-6092-48FE-A4F7-BA0D3A792655}.Debug.ActiveCfg = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792655}.Debug.Build.0 = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792655}.Release.ActiveCfg = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792655}.Release.Build.0 = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792637}.Debug.ActiveCfg = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792637}.Debug.Build.0 = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792637}.Release.ActiveCfg = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792637}.Release.Build.0 = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792632}.Debug.ActiveCfg = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792632}.Debug.Build.0 = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792632}.Release.ActiveCfg = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792632}.Release.Build.0 = Release|Win32
+ {5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Debug.ActiveCfg = Debug|Win32
+ {5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Debug.Build.0 = Debug|Win32
+ {5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Release.ActiveCfg = Release|Win32
+ {5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Release.Build.0 = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D4A792607}.Debug.ActiveCfg = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D4A792607}.Debug.Build.0 = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D4A792607}.Release.ActiveCfg = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D4A792607}.Release.Build.0 = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792606}.Debug.ActiveCfg = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792606}.Debug.Build.0 = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792606}.Release.ActiveCfg = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792606}.Release.Build.0 = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792608}.Debug.ActiveCfg = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792608}.Debug.Build.0 = Debug|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792608}.Release.ActiveCfg = Release|Win32
+ {58CCE183-6092-48FE-A4F7-BA0D3A792608}.Release.Build.0 = Release|Win32
+ {5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Debug.ActiveCfg = Debug|Win32
+ {5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Debug.Build.0 = Debug|Win32
+ {5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Release.ActiveCfg = Release|Win32
+ {5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Release.Build.0 = Release|Win32
+ {FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Debug.ActiveCfg = Debug|Win32
+ {FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Debug.Build.0 = Debug|Win32
+ {FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Release.ActiveCfg = Release|Win32
+ {FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Release.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ EndGlobalSection
+ GlobalSection(ExtensibilityAddIns) = postSolution
+ EndGlobalSection
+EndGlobal

Added: trunk/libs/container/proj/vc7ide/container.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/container.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,318 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="_containerlib"
+ ProjectGUID="{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32"
+ IntermediateDirectory="Debug"
+ ConfigurationType="4"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLibrarianTool"
+ OutputFile="$(OutDir)/d.lib"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32"
+ IntermediateDirectory="Release"
+ ConfigurationType="4"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLibrarianTool"
+ OutputFile="$(OutDir)/container.lib"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="detail"
+ Filter="">
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\adaptive_node_pool_impl.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\advanced_insert_int.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\algorithms.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\allocation_type.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\config_begin.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\config_end.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\destroyers.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\flat_tree.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\iterators.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\math_functions.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\mpl.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\multiallocation_chain.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\node_alloc_holder.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\node_pool_impl.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\pair.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\pool_common.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\preprocessor.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\transform_iterator.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\tree.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\type_traits.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\utilities.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\value_init.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\variadic_templates_tools.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\version_type.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\detail\workaround.hpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Documentation"
+ Filter="">
+ <File
+ RelativePath="..\..\doc\container.qbk">
+ </File>
+ <File
+ RelativePath="..\..\doc\Jamfile.v2">
+ </File>
+ </Filter>
+ <Filter
+ Name="example"
+ Filter="">
+ <File
+ RelativePath="..\..\example\doc_emplace.cpp">
+ </File>
+ <File
+ RelativePath="..\..\example\doc_move_containers.cpp">
+ </File>
+ <File
+ RelativePath="..\..\example\doc_recursive_containers.cpp">
+ </File>
+ <File
+ RelativePath="..\..\example\doc_type_erasure.cpp">
+ </File>
+ <File
+ RelativePath="..\..\example\Jamfile.v2">
+ </File>
+ </Filter>
+ <Filter
+ Name="test"
+ Filter="">
+ <File
+ RelativePath="..\..\test\boost_interprocess_check.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\check_equal_containers.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\deque_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\dummy_test_allocator.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\emplace_test.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\expand_bwd_test_allocator.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\expand_bwd_test_template.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\flat_tree_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\heap_allocator_v1.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\Jamfile.v2">
+ </File>
+ <File
+ RelativePath="..\..\test\list_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\list_test.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\map_test.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\movable_int.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\print_container.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\set_test.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\slist_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\stable_vector_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\string_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\tree_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\util.hpp">
+ </File>
+ <File
+ RelativePath="..\..\test\vector_test.cpp">
+ </File>
+ <File
+ RelativePath="..\..\test\vector_test.hpp">
+ </File>
+ </Filter>
+ <File
+ RelativePath="..\..\..\..\boost\container\container_fwd.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\deque.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\flat_map.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\flat_set.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\list.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\map.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\set.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\slist.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\stable_vector.hpp">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\string.hpp">
+ </File>
+ <File
+ RelativePath="..\to-do.txt">
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\container\vector.hpp">
+ </File>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/deque_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/deque_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="deque_test"
+ ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792655}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/deque_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/deque_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/deque_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/deque_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/deque_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+ <File
+ RelativePath="..\..\test\deque_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/flat_tree_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/flat_tree_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="flat_tree_test"
+ ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792637}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/flat_tree_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ GeneratePreprocessedFile="0"
+ KeepComments="FALSE"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/flat_tree_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/flat_tree_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/flat_tree_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/flat_tree_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+ <File
+ RelativePath="..\..\test\flat_tree_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/list_ex.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/list_ex.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="list_test"
+ ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792632}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/list_ex"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ GeneratePreprocessedFile="0"
+ KeepComments="FALSE"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/list_ex_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/list_ex.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/list_ex"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/list_ex.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+ <File
+ RelativePath="..\..\test\list_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/slist_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/slist_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="slist_test"
+ ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792608}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/slist_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/slist_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/slist_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/slist_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/slist_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+ <File
+ RelativePath="..\..\test\slist_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/stable_vector_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/stable_vector_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="stable_vector_test"
+ ProjectGUID="{5E11C8D3-FA52-760A-84FE-943A6BA05A21}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/stable_vector_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/stable_vector_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/stable_vector_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/stable_vector_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/stable_vector_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{37BC807F-2451-A306-7AC5-7A35A32A22DF}">
+ <File
+ RelativePath="..\..\test\stable_vector_test.cpp">
+ </File>
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/string_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/string_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="string_test"
+ ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D4A792607}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/string_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ GeneratePreprocessedFile="0"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/string_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/string_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/string_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/string_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+ <File
+ RelativePath="..\..\test\string_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/tree_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/tree_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="tree_test"
+ ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792606}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/tree_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/tree_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/tree_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/tree_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/tree_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+ <File
+ RelativePath="..\..\test\tree_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/proj/vc7ide/vector_test.vcproj
==============================================================================
--- (empty file)
+++ trunk/libs/container/proj/vc7ide/vector_test.vcproj 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="7.10"
+ Name="vector_test"
+ ProjectGUID="{5CE11C83-096A-84FE-4FA2-D3A6BA792002}"
+ Keyword="Win32Proj">
+ <Platforms>
+ <Platform
+ Name="Win32"/>
+ </Platforms>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../Bin/Win32/Debug"
+ IntermediateDirectory="Debug/vector_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ MinimalRebuild="TRUE"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="3"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/vector_test_d.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ ProgramDatabaseFile="$(OutDir)/vector_test.pdb"
+ SubSystem="1"
+ TargetMachine="1"
+ FixedBaseAddress="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../Bin/Win32/Release"
+ IntermediateDirectory="Release/vector_test"
+ ConfigurationType="1"
+ CharacterSet="2">
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../.."
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+ RuntimeLibrary="2"
+ TreatWChar_tAsBuiltInType="TRUE"
+ ForceConformanceInForLoopScope="FALSE"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="TRUE"
+ DebugInformationFormat="0"/>
+ <Tool
+ Name="VCCustomBuildTool"/>
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="winmm.lib"
+ OutputFile="$(OutDir)/vector_test.exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../stage/lib"
+ GenerateDebugInformation="TRUE"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ TargetMachine="1"/>
+ <Tool
+ Name="VCMIDLTool"/>
+ <Tool
+ Name="VCPostBuildEventTool"/>
+ <Tool
+ Name="VCPreBuildEventTool"/>
+ <Tool
+ Name="VCPreLinkEventTool"/>
+ <Tool
+ Name="VCResourceCompilerTool"/>
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"/>
+ <Tool
+ Name="VCXMLDataGeneratorTool"/>
+ <Tool
+ Name="VCWebDeploymentTool"/>
+ <Tool
+ Name="VCManagedWrapperGeneratorTool"/>
+ <Tool
+ Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{41737BCF-4312-7AC5-A066-32D75A32A2AF}">
+ <File
+ RelativePath="..\..\test\vector_test.cpp">
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93815995-89BD-b043-5E8B-65FBE52E2AFB}">
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Added: trunk/libs/container/test/Jamfile.v2
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/Jamfile.v2 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,34 @@
+# Boost Container Library Test Jamfile
+
+# (C) Copyright Ion Gaztanaga 2009.
+# Use, modification and distribution are subject to 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)
+
+# Adapted from John Maddock's TR1 Jamfile.v2
+# Copyright John Maddock 2005.
+# Use, modification and distribution are subject to 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)
+
+# this rule enumerates through all the sources and invokes
+# the run rule for each source, the result is a list of all
+# the run rules, which we can pass on to the test_suite rule:
+
+rule test_all
+{
+ local all_rules = ;
+
+ for local fileb in [ glob *.cpp ]
+ {
+ all_rules += [ run $(fileb)
+ : # additional args
+ : # test-files
+ : # requirements
+ ] ;
+ }
+
+ return $(all_rules) ;
+}
+
+test-suite container_test : [ test_all r ] ;

Added: trunk/libs/container/test/check_equal_containers.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/check_equal_containers.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,76 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINERS_HPP
+#define BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINERS_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <functional>
+#include <iostream>
+#include <algorithm>
+
+namespace boost{
+namespace container {
+namespace test{
+
+//Function to check if both containers are equal
+template<class MyBoostCont
+ ,class MyStdCont>
+bool CheckEqualContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+ if(boostcont->size() != stdcont->size())
+ return false;
+
+ typedef typename MyBoostCont::value_type value_type;
+
+ typename MyBoostCont::iterator itboost(boostcont->begin()), itboostend(boostcont->end());
+ typename MyStdCont::iterator itstd(stdcont->begin());
+ typename MyStdCont::size_type dist = (typename MyStdCont::size_type)std::distance(itboost, itboostend);
+ if(dist != boostcont->size()){
+ return false;
+ }
+ std::size_t i = 0;
+ for(; itboost != itboostend; ++itboost, ++itstd, ++i){
+ value_type val(*itstd);
+ const value_type &v = *itboost;
+ if(v != val)
+ return false;
+ }
+ return true;
+}
+
+template<class MyBoostCont
+ ,class MyStdCont>
+bool CheckEqualPairContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+ if(boostcont->size() != stdcont->size())
+ return false;
+
+ typedef typename MyBoostCont::key_type key_type;
+ typedef typename MyBoostCont::mapped_type mapped_type;
+
+ typename MyBoostCont::iterator itboost(boostcont->begin()), itboostend(boostcont->end());
+ typename MyStdCont::iterator itstd(stdcont->begin());
+ for(; itboost != itboostend; ++itboost, ++itstd){
+ if(itboost->first != key_type(itstd->first))
+ return false;
+
+ if(itboost->second != mapped_type(itstd->second))
+ return false;
+ }
+ return true;
+}
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINERS_HPP

Added: trunk/libs/container/test/deque_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/deque_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,295 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <deque>
+#include <iostream>
+#include <functional>
+#include <list>
+
+#include <boost/container/deque.hpp>
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include <boost/move/move.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <string>
+#include "emplace_test.hpp"
+#include "vector_test.hpp"
+
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::deque
+ < test::movable_and_copyable_int
+ , test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool deque_copyable_only(V1 *, V2 *, containers_detail::false_type)
+{
+ return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool deque_copyable_only(V1 *cntdeque, V2 *stddeque, containers_detail::true_type)
+{
+ typedef typename V1::value_type IntType;
+ std::size_t size = cntdeque->size();
+ stddeque->insert(stddeque->end(), 50, 1);
+ cntdeque->insert(cntdeque->end(), 50, 1);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ {
+ IntType move_me(1);
+ stddeque->insert(stddeque->begin()+size/2, 50, 1);
+ cntdeque->insert(cntdeque->begin()+size/2, 50, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ }
+ {
+ IntType move_me(2);
+ cntdeque->assign(cntdeque->size()/2, boost::move(move_me));
+ stddeque->assign(stddeque->size()/2, 2);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ }
+ {
+ IntType move_me(1);
+ stddeque->clear();
+ cntdeque->clear();
+ stddeque->insert(stddeque->begin(), 50, 1);
+ cntdeque->insert(cntdeque->begin(), 50, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ stddeque->insert(stddeque->begin()+20, 50, 1);
+ cntdeque->insert(cntdeque->begin()+20, 50, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ stddeque->insert(stddeque->begin()+20, 20, 1);
+ cntdeque->insert(cntdeque->begin()+20, 20, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ }
+ {
+ IntType move_me(1);
+ stddeque->clear();
+ cntdeque->clear();
+ stddeque->insert(stddeque->end(), 50, 1);
+ cntdeque->insert(cntdeque->end(), 50, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ stddeque->insert(stddeque->end()-20, 50, 1);
+ cntdeque->insert(cntdeque->end()-20, 50, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ stddeque->insert(stddeque->end()-20, 20, 1);
+ cntdeque->insert(cntdeque->end()-20, 20, boost::move(move_me));
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ }
+
+ return true;
+}
+
+//Test recursive structures
+class recursive_deque
+{
+public:
+ int id_;
+ deque<recursive_deque> deque_;
+};
+
+template<class IntType>
+bool do_test()
+{
+ //Test for recursive types
+ {
+ deque<recursive_deque> recursive_deque_deque;
+ }
+
+ {
+ //Now test move semantics
+ deque<recursive_deque> original;
+ deque<recursive_deque> move_ctor(boost::move(original));
+ deque<recursive_deque> move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+ }
+
+ //Alias deque types
+ typedef deque<IntType> MyCntDeque;
+ typedef std::deque<int> MyStdDeque;
+ const int max = 100;
+ try{
+ //Shared memory allocator must be always be initialized
+ //since it has no default constructor
+ MyCntDeque *cntdeque = new MyCntDeque;
+ MyStdDeque *stddeque = new MyStdDeque;
+ //Compare several shared memory deque operations with std::deque
+ int i;
+ for(i = 0; i < max*100; ++i){
+ IntType move_me(i);
+ cntdeque->insert(cntdeque->end(), boost::move(move_me));
+ stddeque->insert(stddeque->end(), i);
+ }
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ cntdeque->clear();
+ stddeque->clear();
+
+ for(i = 0; i < max*100; ++i){
+ IntType move_me(i);
+ cntdeque->push_back(boost::move(move_me));
+ stddeque->push_back(i);
+ }
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ cntdeque->clear();
+ stddeque->clear();
+
+ for(i = 0; i < max*100; ++i){
+ IntType move_me(i);
+ cntdeque->push_front(boost::move(move_me));
+ stddeque->push_front(i);
+ }
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ typename MyCntDeque::iterator it;
+ typename MyCntDeque::const_iterator cit = it;
+
+ cntdeque->erase(cntdeque->begin()++);
+ stddeque->erase(stddeque->begin()++);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ cntdeque->erase(cntdeque->begin());
+ stddeque->erase(stddeque->begin());
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ {
+ //Initialize values
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me (-1);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+
+ cntdeque->insert(cntdeque->end()
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(aux_vect + 50));
+ stddeque->insert(stddeque->end(), aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ for(int i = 0, j = static_cast<int>(cntdeque->size()); i < j; ++i){
+ cntdeque->erase(cntdeque->begin());
+ stddeque->erase(stddeque->begin());
+ }
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ }
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ cntdeque->insert(cntdeque->begin()
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(aux_vect + 50));
+ stddeque->insert(stddeque->begin(), aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+ }
+
+ if(!deque_copyable_only(cntdeque, stddeque
+ ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+ return false;
+ }
+
+ cntdeque->erase(cntdeque->begin());
+ stddeque->erase(stddeque->begin());
+
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ for(i = 0; i < max; ++i){
+ IntType move_me(i);
+ cntdeque->insert(cntdeque->begin(), boost::move(move_me));
+ stddeque->insert(stddeque->begin(), i);
+ }
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+ //Test insertion from list
+ {
+ std::list<int> l(50, int(1));
+ cntdeque->insert(cntdeque->begin(), l.begin(), l.end());
+ stddeque->insert(stddeque->begin(), l.begin(), l.end());
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+ cntdeque->assign(l.begin(), l.end());
+ stddeque->assign(l.begin(), l.end());
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+ }
+
+ cntdeque->resize(100);
+ stddeque->resize(100);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+
+ cntdeque->resize(200);
+ stddeque->resize(200);
+ if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+
+ delete cntdeque;
+ delete stddeque;
+ }
+ catch(std::exception &ex){
+ std::cout << ex.what() << std::endl;
+ return false;
+ }
+
+ std::cout << std::endl << "Test OK!" << std::endl;
+ return true;
+}
+
+
+int main ()
+{
+ if(!do_test<int>())
+ return 1;
+
+ if(!do_test<test::movable_int>())
+ return 1;
+
+ {
+ typedef deque<int> MyDeque;
+ typedef deque<test::movable_int> MyMoveDeque;
+ typedef deque<test::movable_and_copyable_int> MyCopyMoveDeque;
+ typedef deque<test::copyable_int> MyCopyDeque;
+ if(test::vector_test<MyDeque>())
+ return 1;
+ if(test::vector_test<MyMoveDeque>())
+ return 1;
+ if(test::vector_test<MyCopyMoveDeque>())
+ return 1;
+ if(test::vector_test<MyCopyDeque>())
+ return 1;
+ }
+
+ const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
+
+ if(!boost::container::test::test_emplace
+ < deque<test::EmplaceInt>, Options>())
+ return 1;
+
+ return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/dummy_test_allocator.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/dummy_test_allocator.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+#define BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/assert.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/version_type.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+#include <cassert>
+
+//!\file
+//!Describes an allocator to test expand capabilities
+
+namespace boost {
+namespace container {
+namespace test {
+
+//This allocator just allows two allocations. The first one will return
+//mp_buffer + m_offset configured in the constructor. The second one
+//will return mp_buffer.
+template<class T>
+class dummy_test_allocator
+{
+ private:
+ typedef dummy_test_allocator<T> self_t;
+ typedef void * aux_pointer_t;
+ typedef const void * cvoid_ptr;
+
+ template<class T2>
+ dummy_test_allocator& operator=(const dummy_test_allocator<T2>&);
+
+ dummy_test_allocator& operator=(const dummy_test_allocator&);
+
+ public:
+ typedef T value_type;
+ typedef T * pointer;
+ typedef const T * const_pointer;
+ typedef typename containers_detail::add_reference
+ <value_type>::type reference;
+ typedef typename containers_detail::add_reference
+ <const value_type>::type const_reference;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+// typedef boost::container::version_type<dummy_test_allocator, 2> version;
+
+ template<class T2>
+ struct rebind
+ { typedef dummy_test_allocator<T2> other; };
+
+ //!Default constructor. Never throws
+ dummy_test_allocator()
+ {}
+
+ //!Constructor from other dummy_test_allocator. Never throws
+ dummy_test_allocator(const dummy_test_allocator &)
+ {}
+
+ //!Constructor from related dummy_test_allocator. Never throws
+ template<class T2>
+ dummy_test_allocator(const dummy_test_allocator<T2> &)
+ {}
+
+ pointer address(reference value)
+ { return pointer(addressof(value)); }
+
+ const_pointer address(const_reference value) const
+ { return const_pointer(addressof(value)); }
+
+ pointer allocate(size_type, cvoid_ptr = 0)
+ { return 0; }
+
+ void deallocate(const pointer &, size_type)
+ { }
+
+ template<class Convertible>
+ void construct(pointer, const Convertible &)
+ {}
+
+ void destroy(pointer)
+ {}
+
+ size_type max_size() const
+ { return 0; }
+
+ friend void swap(self_t &, self_t &)
+ {}
+
+ //Experimental version 2 dummy_test_allocator functions
+
+ std::pair<pointer, bool>
+ allocation_command(boost::container::allocation_type,
+ size_type,
+ size_type,
+ size_type &, const pointer & = 0)
+ { return std::pair<pointer, bool>(pointer(0), true); }
+
+ //!Returns maximum the number of objects the previously allocated memory
+ //!pointed by p can hold.
+ size_type size(const pointer &) const
+ { return 0; }
+
+ //!Allocates just one object. Memory allocated with this function
+ //!must be deallocated only with deallocate_one().
+ //!Throws boost::container::bad_alloc if there is no enough memory
+ pointer allocate_one()
+ { return pointer(0); }
+
+ //!Deallocates memory previously allocated with allocate_one().
+ //!You should never use deallocate_one to deallocate memory allocated
+ //!with other functions different from allocate_one(). Never throws
+ void deallocate_one(const pointer &)
+ {}
+};
+
+//!Equality test for same type of dummy_test_allocator
+template<class T> inline
+bool operator==(const dummy_test_allocator<T> &,
+ const dummy_test_allocator<T> &)
+{ return false; }
+
+//!Inequality test for same type of dummy_test_allocator
+template<class T> inline
+bool operator!=(const dummy_test_allocator<T> &,
+ const dummy_test_allocator<T> &)
+{ return true; }
+
+} //namespace test {
+} //namespace container {
+} //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+

Added: trunk/libs/container/test/emplace_test.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/emplace_test.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,625 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
+#define BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
+
+#include <iostream>
+#include <typeinfo>
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/move.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/aligned_storage.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+class EmplaceInt
+{
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(EmplaceInt)
+
+ public:
+ EmplaceInt(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0)
+ : a_(a), b_(b), c_(c), d_(d), e_(e)
+ {}
+
+ EmplaceInt(BOOST_RV_REF(EmplaceInt) o)
+ : a_(o.a_), b_(o.b_), c_(o.c_), d_(o.d_), e_(o.e_)
+ {}
+
+ EmplaceInt& operator=(BOOST_RV_REF(EmplaceInt) o)
+ {
+ this->a_ = o.a_;
+ this->b_ = o.b_;
+ this->c_ = o.c_;
+ this->d_ = o.d_;
+ this->e_ = o.e_;
+ return *this;
+ }
+
+ friend bool operator==(const EmplaceInt &l, const EmplaceInt &r)
+ {
+ return l.a_ == r.a_ &&
+ l.b_ == r.b_ &&
+ l.c_ == r.c_ &&
+ l.d_ == r.d_ &&
+ l.e_ == r.e_;
+ }
+
+ friend bool operator<(const EmplaceInt &l, const EmplaceInt &r)
+ { return l.sum() < r.sum(); }
+
+ friend bool operator>(const EmplaceInt &l, const EmplaceInt &r)
+ { return l.sum() > r.sum(); }
+
+ friend bool operator!=(const EmplaceInt &l, const EmplaceInt &r)
+ { return !(l == r); }
+
+ friend std::ostream &operator <<(std::ostream &os, const EmplaceInt &v)
+ {
+ os << "EmplaceInt: " << v.a_ << ' ' << v.b_ << ' ' << v.c_ << ' ' << v.d_ << ' ' << v.e_;
+ return os;
+ }
+
+ ~EmplaceInt()
+ { a_ = b_ = c_ = d_ = e_ = 0; }
+
+ //private:
+ int sum() const
+ { return this->a_ + this->b_ + this->c_ + this->d_ + this->e_; }
+
+ int a_, b_, c_, d_, e_;
+ int padding[6];
+};
+
+
+} //namespace test {
+
+namespace test {
+
+enum EmplaceOptions{
+ EMPLACE_BACK = 1 << 0,
+ EMPLACE_FRONT = 1 << 1,
+ EMPLACE_BEFORE = 1 << 2,
+ EMPLACE_AFTER = 1 << 3,
+ EMPLACE_ASSOC = 1 << 4,
+ EMPLACE_HINT = 1 << 5,
+ EMPLACE_ASSOC_PAIR = 1 << 6,
+ EMPLACE_HINT_PAIR = 1 << 7
+};
+
+template<class Container>
+bool test_expected_container(const Container &ec, const EmplaceInt *Expected, unsigned int only_first_n)
+{
+ typedef typename Container::const_iterator const_iterator;
+ const_iterator itb(ec.begin()), ite(ec.end());
+ unsigned int cur = 0;
+ if(only_first_n > ec.size()){
+ return false;
+ }
+ for(; itb != ite && only_first_n--; ++itb, ++cur){
+ const EmplaceInt & cr = *itb;
+ if(cr != Expected[cur]){
+ return false;
+ }
+ }
+ return true;
+}
+
+template<class Container>
+bool test_expected_container(const Container &ec, const std::pair<EmplaceInt, EmplaceInt> *Expected, unsigned int only_first_n)
+{
+ typedef typename Container::const_iterator const_iterator;
+ const_iterator itb(ec.begin()), ite(ec.end());
+ unsigned int cur = 0;
+ if(only_first_n > ec.size()){
+ return false;
+ }
+ for(; itb != ite && only_first_n--; ++itb, ++cur){
+ if(itb->first != Expected[cur].first){
+ std::cout << "Error in first: " << itb->first << ' ' << Expected[cur].first << std::endl;
+ return false;
+
+ }
+ else if(itb->second != Expected[cur].second){
+ std::cout << "Error in second: " << itb->second << ' ' << Expected[cur].second << std::endl;
+ return false;
+ }
+ }
+ return true;
+}
+
+static EmplaceInt expected [10];
+
+typedef std::pair<EmplaceInt, EmplaceInt> EmplaceIntPair;
+static boost::aligned_storage<sizeof(EmplaceIntPair)*10>::type pair_storage;
+
+static EmplaceIntPair* initialize_emplace_int_pair()
+{
+ EmplaceIntPair* ret = reinterpret_cast<EmplaceIntPair*>(&pair_storage);
+ for(unsigned int i = 0; i != 10; ++i){
+ new(&ret->first)EmplaceInt();
+ new(&ret->second)EmplaceInt();
+ }
+ return ret;
+}
+
+static EmplaceIntPair * expected_pair = initialize_emplace_int_pair();
+
+
+template<class Container>
+bool test_emplace_back(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_back." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ {
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt(1, 2);
+ new(&expected [3]) EmplaceInt(1, 2, 3);
+ new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+ new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+ Container c;
+ c.emplace_back();
+ if(!test_expected_container(c, &expected[0], 1))
+ return false;
+ c.emplace_back(1);
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ c.emplace_back(1, 2);
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ c.emplace_back(1, 2, 3);
+ if(!test_expected_container(c, &expected[0], 4))
+ return false;
+ c.emplace_back(1, 2, 3, 4);
+ if(!test_expected_container(c, &expected[0], 5))
+ return false;
+ c.emplace_back(1, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ }
+
+ return true;
+}
+
+template<class Container>
+bool test_emplace_back(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_front(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_front." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ {
+ new(&expected [0]) EmplaceInt(1, 2, 3, 4, 5);
+ new(&expected [1]) EmplaceInt(1, 2, 3, 4);
+ new(&expected [2]) EmplaceInt(1, 2, 3);
+ new(&expected [3]) EmplaceInt(1, 2);
+ new(&expected [4]) EmplaceInt(1);
+ new(&expected [5]) EmplaceInt();
+ Container c;
+ c.emplace_front();
+ if(!test_expected_container(c, &expected[0] + 5, 1))
+ return false;
+ c.emplace_front(1);/*
+ if(!test_expected_container(c, &expected[0] + 4, 2))
+ return false;
+ c.emplace_front(1, 2);
+ if(!test_expected_container(c, &expected[0] + 3, 3))
+ return false;
+ c.emplace_front(1, 2, 3);
+ if(!test_expected_container(c, &expected[0] + 2, 4))
+ return false;
+ c.emplace_front(1, 2, 3, 4);
+ if(!test_expected_container(c, &expected[0] + 1, 5))
+ return false;
+ c.emplace_front(1, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected[0] + 0, 6))
+ return false;*/
+ }
+ return true;
+}
+
+template<class Container>
+bool test_emplace_front(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_before(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_before." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ {
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt();
+ Container c;
+ c.emplace(c.cend(), 1);
+ c.emplace(c.cbegin());
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ c.emplace(c.cend());
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ }
+ {
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt(1, 2);
+ new(&expected [3]) EmplaceInt(1, 2, 3);
+ new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+ new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+ //emplace_front-like
+ Container c;
+ c.emplace(c.cbegin(), 1, 2, 3, 4, 5);
+ c.emplace(c.cbegin(), 1, 2, 3, 4);
+ c.emplace(c.cbegin(), 1, 2, 3);
+ c.emplace(c.cbegin(), 1, 2);
+ c.emplace(c.cbegin(), 1);
+ c.emplace(c.cbegin());
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ c.clear();
+ //emplace_back-like
+ typename Container::const_iterator i = c.emplace(c.cend());
+ if(!test_expected_container(c, &expected[0], 1))
+ return false;
+ i = c.emplace(++i, 1);
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ i = c.emplace(++i, 1, 2);
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ i = c.emplace(++i, 1, 2, 3);
+ if(!test_expected_container(c, &expected[0], 4))
+ return false;
+ i = c.emplace(++i, 1, 2, 3, 4);
+ if(!test_expected_container(c, &expected[0], 5))
+ return false;
+ i = c.emplace(++i, 1, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ c.clear();
+ //emplace in the middle
+ c.emplace(c.cbegin());
+ i = c.emplace(c.cend(), 1, 2, 3, 4, 5);
+ i = c.emplace(i, 1, 2, 3, 4);
+ i = c.emplace(i, 1, 2, 3);
+ i = c.emplace(i, 1, 2);
+ i = c.emplace(i, 1);
+
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ }
+ return true;
+}
+
+template<class Container>
+bool test_emplace_before(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_after(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_after." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+ {
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt();
+ Container c;
+ typename Container::const_iterator i = c.emplace_after(c.cbefore_begin(), 1);
+ c.emplace_after(c.cbefore_begin());
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ c.emplace_after(i);
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ }
+ {
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt(1, 2);
+ new(&expected [3]) EmplaceInt(1, 2, 3);
+ new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+ new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+ //emplace_front-like
+ Container c;
+ c.emplace_after(c.cbefore_begin(), 1, 2, 3, 4, 5);
+ c.emplace_after(c.cbefore_begin(), 1, 2, 3, 4);
+ c.emplace_after(c.cbefore_begin(), 1, 2, 3);
+ c.emplace_after(c.cbefore_begin(), 1, 2);
+ c.emplace_after(c.cbefore_begin(), 1);
+ c.emplace_after(c.cbefore_begin());
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ c.clear();
+ //emplace_back-like
+ typename Container::const_iterator i = c.emplace_after(c.cbefore_begin());
+ if(!test_expected_container(c, &expected[0], 1))
+ return false;
+ i = c.emplace_after(i, 1);
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ i = c.emplace_after(i, 1, 2);
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ i = c.emplace_after(i, 1, 2, 3);
+ if(!test_expected_container(c, &expected[0], 4))
+ return false;
+ i = c.emplace_after(i, 1, 2, 3, 4);
+ if(!test_expected_container(c, &expected[0], 5))
+ return false;
+ i = c.emplace_after(i, 1, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ c.clear();
+ //emplace_after in the middle
+ i = c.emplace_after(c.cbefore_begin());
+ c.emplace_after(i, 1, 2, 3, 4, 5);
+ c.emplace_after(i, 1, 2, 3, 4);
+ c.emplace_after(i, 1, 2, 3);
+ c.emplace_after(i, 1, 2);
+ c.emplace_after(i, 1);
+
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ }
+ return true;
+}
+
+template<class Container>
+bool test_emplace_after(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_assoc(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_assoc." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt(1, 2);
+ new(&expected [3]) EmplaceInt(1, 2, 3);
+ new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+ new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+ {
+ Container c;
+ c.emplace();
+ if(!test_expected_container(c, &expected[0], 1))
+ return false;
+ c.emplace(1);
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ c.emplace(1, 2);
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ c.emplace(1, 2, 3);
+ if(!test_expected_container(c, &expected[0], 4))
+ return false;
+ c.emplace(1, 2, 3, 4);
+ if(!test_expected_container(c, &expected[0], 5))
+ return false;
+ c.emplace(1, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ }
+ return true;
+}
+
+template<class Container>
+bool test_emplace_assoc(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_hint(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_hint." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ new(&expected [0]) EmplaceInt();
+ new(&expected [1]) EmplaceInt(1);
+ new(&expected [2]) EmplaceInt(1, 2);
+ new(&expected [3]) EmplaceInt(1, 2, 3);
+ new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+ new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+
+ {
+ Container c;
+ typename Container::const_iterator it;
+ it = c.emplace_hint(c.begin());
+ if(!test_expected_container(c, &expected[0], 1))
+ return false;
+ it = c.emplace_hint(it, 1);
+ if(!test_expected_container(c, &expected[0], 2))
+ return false;
+ it = c.emplace_hint(it, 1, 2);
+ if(!test_expected_container(c, &expected[0], 3))
+ return false;
+ it = c.emplace_hint(it, 1, 2, 3);
+ if(!test_expected_container(c, &expected[0], 4))
+ return false;
+ it = c.emplace_hint(it, 1, 2, 3, 4);
+ if(!test_expected_container(c, &expected[0], 5))
+ return false;
+ it = c.emplace_hint(it, 1, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected[0], 6))
+ return false;
+ }
+
+ return true;
+}
+
+template<class Container>
+bool test_emplace_hint(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_assoc_pair(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_assoc_pair." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ new(&expected_pair[0].first) EmplaceInt();
+ new(&expected_pair[0].second) EmplaceInt();
+ new(&expected_pair[1].first) EmplaceInt(1);
+ new(&expected_pair[1].second) EmplaceInt();
+ new(&expected_pair[2].first) EmplaceInt(2);
+ new(&expected_pair[2].second) EmplaceInt(2);
+ new(&expected_pair[3].first) EmplaceInt(3);
+ new(&expected_pair[3].second) EmplaceInt(2, 3);
+ new(&expected_pair[4].first) EmplaceInt(4);
+ new(&expected_pair[4].second) EmplaceInt(2, 3, 4);
+ new(&expected_pair[5].first) EmplaceInt(5);
+ new(&expected_pair[5].second) EmplaceInt(2, 3, 4, 5);
+ {
+ Container c;
+ c.emplace();
+ if(!test_expected_container(c, &expected_pair[0], 1)){
+ std::cout << "Error after c.emplace();\n";
+ return false;
+ }
+ c.emplace(1);
+ if(!test_expected_container(c, &expected_pair[0], 2)){
+ std::cout << "Error after c.emplace(1);\n";
+ return false;
+ }
+ c.emplace(2, 2);
+ if(!test_expected_container(c, &expected_pair[0], 3)){
+ std::cout << "Error after c.emplace(2, 2);\n";
+ return false;
+ }
+ c.emplace(3, 2, 3);
+ if(!test_expected_container(c, &expected_pair[0], 4)){
+ std::cout << "Error after c.emplace(3, 2, 3);\n";
+ return false;
+ }
+ c.emplace(4, 2, 3, 4);
+ if(!test_expected_container(c, &expected_pair[0], 5)){
+ std::cout << "Error after c.emplace(4, 2, 3, 4);\n";
+ return false;
+ }
+ c.emplace(5, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected_pair[0], 6)){
+ std::cout << "Error after c.emplace(5, 2, 3, 4, 5);\n";
+ return false;
+ }
+ }
+ return true;
+}
+
+template<class Container>
+bool test_emplace_assoc_pair(containers_detail::false_)
+{ return true; }
+
+template<class Container>
+bool test_emplace_hint_pair(containers_detail::true_)
+{
+ std::cout << "Starting test_emplace_hint_pair." << std::endl << " Class: "
+ << typeid(Container).name() << std::endl;
+
+ new(&expected_pair[0].first) EmplaceInt();
+ new(&expected_pair[0].second) EmplaceInt();
+ new(&expected_pair[1].first) EmplaceInt(1);
+ new(&expected_pair[1].second) EmplaceInt();
+ new(&expected_pair[2].first) EmplaceInt(2);
+ new(&expected_pair[2].second) EmplaceInt(2);
+ new(&expected_pair[3].first) EmplaceInt(3);
+ new(&expected_pair[3].second) EmplaceInt(2, 3);
+ new(&expected_pair[4].first) EmplaceInt(4);
+ new(&expected_pair[4].second) EmplaceInt(2, 3, 4);
+ new(&expected_pair[5].first) EmplaceInt(5);
+ new(&expected_pair[5].second) EmplaceInt(2, 3, 4, 5);
+ {
+ Container c;
+ typename Container::const_iterator it;
+ it = c.emplace_hint(c.begin());
+ if(!test_expected_container(c, &expected_pair[0], 1)){
+ std::cout << "Error after c.emplace(1);\n";
+ return false;
+ }
+ it = c.emplace_hint(it, 1);
+ if(!test_expected_container(c, &expected_pair[0], 2)){
+ std::cout << "Error after c.emplace(it, 1);\n";
+ return false;
+ }
+ it = c.emplace_hint(it, 2, 2);
+ if(!test_expected_container(c, &expected_pair[0], 3)){
+ std::cout << "Error after c.emplace(it, 2, 2);\n";
+ return false;
+ }
+ it = c.emplace_hint(it, 3, 2, 3);
+ if(!test_expected_container(c, &expected_pair[0], 4)){
+ std::cout << "Error after c.emplace(it, 3, 2, 3);\n";
+ return false;
+ }
+ it = c.emplace_hint(it, 4, 2, 3, 4);
+ if(!test_expected_container(c, &expected_pair[0], 5)){
+ std::cout << "Error after c.emplace(it, 4, 2, 3, 4);\n";
+ return false;
+ }
+ it = c.emplace_hint(it, 5, 2, 3, 4, 5);
+ if(!test_expected_container(c, &expected_pair[0], 6)){
+ std::cout << "Error after c.emplace(it, 5, 2, 3, 4, 5);\n";
+ return false;
+ }
+ }
+ return true;
+}
+
+template<class Container>
+bool test_emplace_hint_pair(containers_detail::false_)
+{ return true; }
+
+template <EmplaceOptions O, EmplaceOptions Mask>
+struct emplace_active
+{
+ static const bool value = (0 != (O & Mask));
+ typedef containers_detail::bool_<value> type;
+ operator type() const{ return type(); }
+};
+
+template<class Container, EmplaceOptions O>
+bool test_emplace()
+{
+// if(!test_emplace_back<Container>(emplace_active<O, EMPLACE_BACK>()))
+// return false;
+ if(!test_emplace_front<Container>(emplace_active<O, EMPLACE_FRONT>()))
+ return false;/*
+ if(!test_emplace_before<Container>(emplace_active<O, EMPLACE_BEFORE>()))
+ return false;
+ if(!test_emplace_after<Container>(emplace_active<O, EMPLACE_AFTER>()))
+ return false;
+ if(!test_emplace_assoc<Container>(emplace_active<O, EMPLACE_ASSOC>()))
+ return false;
+ if(!test_emplace_hint<Container>(emplace_active<O, EMPLACE_HINT>()))
+ return false;
+ if(!test_emplace_assoc_pair<Container>(emplace_active<O, EMPLACE_ASSOC_PAIR>()))
+ return false;
+ if(!test_emplace_hint_pair<Container>(emplace_active<O, EMPLACE_HINT_PAIR>()))
+ return false;*/
+ return true;
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP

Added: trunk/libs/container/test/expand_bwd_test_allocator.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/expand_bwd_test_allocator.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,193 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+#define BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/assert.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/version_type.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+#include <cassert>
+
+//!\file
+//!Describes an allocator to test expand capabilities
+
+namespace boost {
+namespace container {
+namespace test {
+
+//This allocator just allows two allocations. The first one will return
+//mp_buffer + m_offset configured in the constructor. The second one
+//will return mp_buffer.
+template<class T>
+class expand_bwd_test_allocator
+{
+ private:
+ typedef expand_bwd_test_allocator<T> self_t;
+ typedef void * aux_pointer_t;
+ typedef const void * cvoid_ptr;
+
+ template<class T2>
+ expand_bwd_test_allocator& operator=(const expand_bwd_test_allocator<T2>&);
+
+ expand_bwd_test_allocator& operator=(const expand_bwd_test_allocator&);
+
+ public:
+ typedef T value_type;
+ typedef T * pointer;
+ typedef const T * const_pointer;
+ typedef typename containers_detail::add_reference
+ <value_type>::type reference;
+ typedef typename containers_detail::add_reference
+ <const value_type>::type const_reference;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ typedef boost::container::containers_detail::version_type<expand_bwd_test_allocator, 2> version;
+
+ template<class T2>
+ struct rebind
+ { typedef expand_bwd_test_allocator<T2> other; };
+
+ //!Constructor from the segment manager. Never throws
+ expand_bwd_test_allocator(T *buffer, size_type size, difference_type offset)
+ : mp_buffer(buffer), m_size(size)
+ , m_offset(offset), m_allocations(0){ }
+
+ //!Constructor from other expand_bwd_test_allocator. Never throws
+ expand_bwd_test_allocator(const expand_bwd_test_allocator &other)
+ : mp_buffer(other.mp_buffer), m_size(other.m_size)
+ , m_offset(other.m_offset), m_allocations(0){ }
+
+ //!Constructor from related expand_bwd_test_allocator. Never throws
+ template<class T2>
+ expand_bwd_test_allocator(const expand_bwd_test_allocator<T2> &other)
+ : mp_buffer(other.mp_buffer), m_size(other.m_size)
+ , m_offset(other.m_offset), m_allocations(0){ }
+
+ pointer address(reference value)
+ { return pointer(addressof(value)); }
+
+ const_pointer address(const_reference value) const
+ { return const_pointer(addressof(value)); }
+
+ pointer allocate(size_type , cvoid_ptr hint = 0)
+ { (void)hint; return 0; }
+
+ void deallocate(const pointer &, size_type)
+ {}
+
+ template<class Convertible>
+ void construct(pointer ptr, const Convertible &value)
+ { new((void*)ptr) value_type(value); }
+
+ void destroy(pointer ptr)
+ { (*ptr).~value_type(); }
+
+ size_type max_size() const
+ { return m_size; }
+
+ friend void swap(self_t &alloc1, self_t &alloc2)
+ {
+ containers_detail::do_swap(alloc1.mp_buffer, alloc2.mp_buffer);
+ containers_detail::do_swap(alloc1.m_size, alloc2.m_size);
+ containers_detail::do_swap(alloc1.m_offset, alloc2.m_offset);
+ }
+
+ //Experimental version 2 expand_bwd_test_allocator functions
+
+ std::pair<pointer, bool>
+ allocation_command(boost::container::allocation_type command,
+ size_type limit_size,
+ size_type preferred_size,
+ size_type &received_size, const pointer &reuse = 0)
+ {
+ (void)preferred_size; (void)reuse; (void)command;
+ //This allocator only expands backwards!
+ assert(m_allocations == 0 || (command & boost::container::expand_bwd));
+
+ received_size = limit_size;
+
+ if(m_allocations == 0){
+ if((m_offset + limit_size) > m_size){
+ assert(0);
+ }
+ ++m_allocations;
+ return std::pair<pointer, bool>(mp_buffer + m_offset, false);
+ }
+ else if(m_allocations == 1){
+ if(limit_size > m_size){
+ assert(0);
+ }
+ ++m_allocations;
+ return std::pair<pointer, bool>(mp_buffer, true);
+ }
+ else{
+ assert(0);
+ throw std::bad_alloc();
+ }
+ }
+
+ //!Returns maximum the number of objects the previously allocated memory
+ //!pointed by p can hold.
+ size_type size(const pointer &p) const
+ { (void)p; return m_size; }
+
+ //!Allocates just one object. Memory allocated with this function
+ //!must be deallocated only with deallocate_one().
+ //!Throws boost::container::bad_alloc if there is no enough memory
+ pointer allocate_one()
+ { return this->allocate(1); }
+
+ //!Deallocates memory previously allocated with allocate_one().
+ //!You should never use deallocate_one to deallocate memory allocated
+ //!with other functions different from allocate_one(). Never throws
+ void deallocate_one(const pointer &p)
+ { return this->deallocate(p, 1); }
+
+ pointer mp_buffer;
+ size_type m_size;
+ difference_type m_offset;
+ char m_allocations;
+};
+
+//!Equality test for same type of expand_bwd_test_allocator
+template<class T> inline
+bool operator==(const expand_bwd_test_allocator<T> &alloc1,
+ const expand_bwd_test_allocator<T> &alloc2)
+{ return false; }
+
+//!Inequality test for same type of expand_bwd_test_allocator
+template<class T> inline
+bool operator!=(const expand_bwd_test_allocator<T> &alloc1,
+ const expand_bwd_test_allocator<T> &alloc2)
+{ return true; }
+
+} //namespace test {
+} //namespace container {
+} //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+

Added: trunk/libs/container/test/expand_bwd_test_template.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/expand_bwd_test_template.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,269 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
+#define BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <vector>
+#include <typeinfo>
+#include "expand_bwd_test_allocator.hpp"
+#include <algorithm>
+#include <boost/type_traits/remove_volatile.hpp>
+
+namespace boost { namespace container { namespace test {
+
+template<class T>
+struct value_holder
+{
+ value_holder(T val) : m_value(val){}
+ value_holder(): m_value(0){}
+ ~value_holder(){ m_value = 0; }
+ bool operator == (const value_holder &other) const
+ { return m_value == other.m_value; }
+ bool operator != (const value_holder &other) const
+ { return m_value != other.m_value; }
+
+ T m_value;
+};
+
+template<class T>
+struct triple_value_holder
+{
+ triple_value_holder(T val)
+ : m_value1(val)
+ , m_value2(val)
+ , m_value3(val)
+ {}
+
+ triple_value_holder()
+ : m_value1(0)
+ , m_value2(0)
+ , m_value3(0)
+ {}
+
+ ~triple_value_holder()
+ { m_value1 = m_value2 = m_value3 = 0; }
+
+ bool operator == (const triple_value_holder &other) const
+ {
+ return m_value1 == other.m_value1
+ && m_value2 == other.m_value2
+ && m_value3 == other.m_value3;
+ }
+
+ bool operator != (const triple_value_holder &other) const
+ {
+ return m_value1 != other.m_value1
+ || m_value2 != other.m_value2
+ || m_value3 != other.m_value3;
+ }
+
+ T m_value1;
+ T m_value2;
+ T m_value3;
+};
+
+typedef value_holder<int> int_holder;
+typedef triple_value_holder<int> triple_int_holder;
+
+
+
+//Function to check if both sets are equal
+template <class Vector1, class Vector2>
+bool CheckEqualVector(const Vector1 &vector1, const Vector2 &vector2)
+{
+ if(vector1.size() != vector2.size())
+ return false;
+ return std::equal(vector1.begin(), vector1.end(), vector2.begin());
+}
+
+template<class Vector>
+bool CheckUninitializedIsZero(const Vector & v)
+{
+ typedef typename Vector::value_type value_type;
+ typename Vector::size_type sz = v.size();
+ typename Vector::size_type extra = v.capacity() - v.size();
+ value_type comp(0);
+
+ const value_type *holder = &v[0] + sz;
+
+ while(extra--){
+ if(*holder++ != comp)
+ return false;
+ }
+ return true;
+}
+
+
+//This function tests all the possible combinations when
+//inserting data in a vector and expanding backwards
+template<class VectorWithExpandBwdAllocator>
+bool test_insert_with_expand_bwd()
+{
+ typedef typename VectorWithExpandBwdAllocator::value_type value_type;
+ typedef typename boost::remove_volatile<value_type>::type non_volatile_value_type;
+ typedef std::vector<non_volatile_value_type> Vect;
+ const int MemorySize = 1000;
+
+ //Distance old and new buffer
+ const int Offset[] =
+ { 350, 250, 150, 150,
+ 150, 50, 50, 50 };
+ //Insert position
+ const int Position[] =
+ { 100, 100, 100, 100,
+ 100, 100, 100, 100 };
+ //Initial vector size
+ const int InitialSize[] =
+ { 200, 200, 200, 200,
+ 200, 200, 200, 200 };
+ //Size of the data to insert
+ const int InsertSize[] =
+ { 100, 100, 100, 200,
+ 300, 25, 100, 200 };
+ //Number of tests
+ const int Iterations = sizeof(InsertSize)/sizeof(int);
+
+ for(int iteration = 0; iteration < Iterations; ++iteration)
+ {
+ value_type *memory = new value_type[MemorySize];
+ try {
+ std::vector<non_volatile_value_type> initial_data;
+ initial_data.resize(InitialSize[iteration]);
+ for(int i = 0; i < InitialSize[iteration]; ++i){
+ initial_data[i] = i;
+ }
+
+ Vect data_to_insert;
+ data_to_insert.resize(InsertSize[iteration]);
+ for(int i = 0; i < InsertSize[iteration]; ++i){
+ data_to_insert[i] = -i;
+ }
+
+ expand_bwd_test_allocator<value_type> alloc
+ (&memory[0], MemorySize, Offset[iteration]);
+ VectorWithExpandBwdAllocator vector(alloc);
+ vector.insert( vector.begin()
+ , initial_data.begin(), initial_data.end());
+ vector.insert( vector.begin() + Position[iteration]
+ , data_to_insert.begin(), data_to_insert.end());
+ initial_data.insert(initial_data.begin() + Position[iteration]
+ , data_to_insert.begin(), data_to_insert.end());
+ //Now check that values are equal
+ if(!CheckEqualVector(vector, initial_data)){
+ std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl
+ << " Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
+ << " Iteration: " << iteration << std::endl;
+ return false;
+ }
+ }
+ catch(...){
+ delete [](const_cast<non_volatile_value_type*>(memory));
+ throw;
+ }
+ delete [](const_cast<non_volatile_value_type*>(memory));
+ }
+
+ return true;
+}
+
+//This function tests all the possible combinations when
+//inserting data in a vector and expanding backwards
+template<class VectorWithExpandBwdAllocator>
+bool test_assign_with_expand_bwd()
+{
+ typedef typename VectorWithExpandBwdAllocator::value_type value_type;
+ typedef typename boost::remove_volatile<value_type>::type non_volatile_value_type;
+ typedef std::vector<non_volatile_value_type> Vect;
+ const int MemorySize = 200;
+
+ const int Offset[] = { 50, 50, 50};
+ const int InitialSize[] = { 25, 25, 25};
+ const int AssignSize[] = { 40, 60, 80};
+ const int Iterations = sizeof(AssignSize)/sizeof(int);
+
+ for(int iteration = 0; iteration <Iterations; ++iteration)
+ {
+ value_type *memory = new value_type[MemorySize];
+ try {
+ //Create initial data
+ std::vector<non_volatile_value_type> initial_data;
+ initial_data.resize(InitialSize[iteration]);
+ for(int i = 0; i < InitialSize[iteration]; ++i){
+ initial_data[i] = i;
+ }
+
+ //Create data to assign
+ std::vector<non_volatile_value_type> data_to_assign;
+ data_to_assign.resize(AssignSize[iteration]);
+ for(int i = 0; i < AssignSize[iteration]; ++i){
+ data_to_assign[i] = -i;
+ }
+
+ //Insert initial data to the vector to test
+ expand_bwd_test_allocator<value_type> alloc
+ (&memory[0], MemorySize, Offset[iteration]);
+ VectorWithExpandBwdAllocator vector(alloc);
+ vector.insert( vector.begin()
+ , initial_data.begin(), initial_data.end());
+
+ //Assign data
+ vector.assign(data_to_assign.begin(), data_to_assign.end());
+ initial_data.assign(data_to_assign.begin(), data_to_assign.end());
+
+ //Now check that values are equal
+ if(!CheckEqualVector(vector, initial_data)){
+ std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl
+ << " Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
+ << " Iteration: " << iteration << std::endl;
+ return false;
+ }
+ }
+ catch(...){
+ delete [](const_cast<typename boost::remove_volatile<value_type>::type*>(memory));
+ throw;
+ }
+ delete [](const_cast<typename boost::remove_volatile<value_type>::type*>(memory));
+ }
+
+ return true;
+}
+
+//This function calls all tests
+template<class VectorWithExpandBwdAllocator>
+bool test_all_expand_bwd()
+{
+ std::cout << "Starting test_insert_with_expand_bwd." << std::endl << " Class: "
+ << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+
+ if(!test_insert_with_expand_bwd<VectorWithExpandBwdAllocator>()){
+ std::cout << "test_allocation_direct_deallocation failed. Class: "
+ << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+ return false;
+ }
+
+ std::cout << "Starting test_assign_with_expand_bwd." << std::endl << " Class: "
+ << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+
+ if(!test_assign_with_expand_bwd<VectorWithExpandBwdAllocator>()){
+ std::cout << "test_allocation_direct_deallocation failed. Class: "
+ << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+ return false;
+ }
+
+ return true;
+}
+
+}}} //namespace boost { namespace container { namespace test {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER

Added: trunk/libs/container/test/flat_tree_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/flat_tree_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,333 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <set>
+#include <boost/container/flat_set.hpp>
+#include <boost/container/flat_map.hpp>
+#include "print_container.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "set_test.hpp"
+#include "map_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Alias allocator type
+typedef std::allocator<int> allocator_t;
+typedef std::allocator<test::movable_int>
+ movable_allocator_t;
+typedef std::allocator<std::pair<int, int> >
+ pair_allocator_t;
+typedef std::allocator<std::pair<test::movable_int, test::movable_int> >
+ movable_pair_allocator_t;
+typedef std::allocator<test::movable_and_copyable_int >
+ move_copy_allocator_t;
+typedef std::allocator<std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
+ move_copy_pair_allocator_t;
+typedef std::allocator<test::copyable_int >
+ copy_allocator_t;
+typedef std::allocator<std::pair<test::copyable_int, test::copyable_int> >
+ copy_pair_allocator_t;
+
+
+//Alias set types
+typedef std::set<int> MyStdSet;
+typedef std::multiset<int> MyStdMultiSet;
+typedef std::map<int, int> MyStdMap;
+typedef std::multimap<int, int> MyStdMultiMap;
+
+typedef flat_set<int, std::less<int>, allocator_t> MyBoostSet;
+typedef flat_multiset<int, std::less<int>, allocator_t> MyBoostMultiSet;
+typedef flat_map<int, int, std::less<int>, pair_allocator_t> MyBoostMap;
+typedef flat_multimap<int, int, std::less<int>, pair_allocator_t> MyBoostMultiMap;
+
+typedef flat_set<test::movable_int, std::less<test::movable_int>
+ ,movable_allocator_t> MyMovableBoostSet;
+typedef flat_multiset<test::movable_int,std::less<test::movable_int>
+ ,movable_allocator_t> MyMovableBoostMultiSet;
+typedef flat_map<test::movable_int, test::movable_int
+ ,std::less<test::movable_int>
+ ,movable_pair_allocator_t> MyMovableBoostMap;
+typedef flat_multimap<test::movable_int, test::movable_int
+ ,std::less<test::movable_int>
+ ,movable_pair_allocator_t> MyMovableBoostMultiMap;
+
+typedef flat_set<test::movable_and_copyable_int, std::less<test::movable_and_copyable_int>
+ ,move_copy_allocator_t> MyMoveCopyBoostSet;
+typedef flat_multiset<test::movable_and_copyable_int,std::less<test::movable_and_copyable_int>
+ ,move_copy_allocator_t> MyMoveCopyBoostMultiSet;
+typedef flat_map<test::movable_and_copyable_int, test::movable_and_copyable_int
+ ,std::less<test::movable_and_copyable_int>
+ ,move_copy_pair_allocator_t> MyMoveCopyBoostMap;
+typedef flat_multimap<test::movable_and_copyable_int, test::movable_and_copyable_int
+ ,std::less<test::movable_and_copyable_int>
+ ,move_copy_pair_allocator_t> MyMoveCopyBoostMultiMap;
+
+typedef flat_set<test::copyable_int, std::less<test::copyable_int>
+ ,copy_allocator_t> MyCopyBoostSet;
+typedef flat_multiset<test::copyable_int,std::less<test::copyable_int>
+ ,copy_allocator_t> MyCopyBoostMultiSet;
+typedef flat_map<test::copyable_int, test::copyable_int
+ ,std::less<test::copyable_int>
+ ,copy_pair_allocator_t> MyCopyBoostMap;
+typedef flat_multimap<test::copyable_int, test::copyable_int
+ ,std::less<test::copyable_int>
+ ,copy_pair_allocator_t> MyCopyBoostMultiMap;
+
+
+
+//Test recursive structures
+class recursive_flat_set
+{
+ public:
+ recursive_flat_set(const recursive_flat_set &c)
+ : id_(c.id_), flat_set_(c.flat_set_)
+ {}
+
+ recursive_flat_set & operator =(const recursive_flat_set &c)
+ {
+ id_ = c.id_;
+ flat_set_= c.flat_set_;
+ return *this;
+ }
+ int id_;
+ flat_set<recursive_flat_set> flat_set_;
+ friend bool operator< (const recursive_flat_set &a, const recursive_flat_set &b)
+ { return a.id_ < b.id_; }
+};
+
+
+
+class recursive_flat_map
+{
+ public:
+ recursive_flat_map(const recursive_flat_map &c)
+ : id_(c.id_), map_(c.map_)
+ {}
+
+ recursive_flat_map & operator =(const recursive_flat_map &c)
+ {
+ id_ = c.id_;
+ map_= c.map_;
+ return *this;
+ }
+
+ int id_;
+ flat_map<recursive_flat_map, recursive_flat_map> map_;
+
+ friend bool operator< (const recursive_flat_map &a, const recursive_flat_map &b)
+ { return a.id_ < b.id_; }
+};
+
+//Test recursive structures
+class recursive_flat_multiset
+{
+ public:
+ recursive_flat_multiset(const recursive_flat_multiset &c)
+ : id_(c.id_), flat_set_(c.flat_set_)
+ {}
+
+ recursive_flat_multiset & operator =(const recursive_flat_multiset &c)
+ {
+ id_ = c.id_;
+ flat_set_= c.flat_set_;
+ return *this;
+ }
+ int id_;
+ flat_multiset<recursive_flat_multiset> flat_set_;
+ friend bool operator< (const recursive_flat_multiset &a, const recursive_flat_multiset &b)
+ { return a.id_ < b.id_; }
+};
+
+class recursive_flat_multimap
+{
+public:
+ recursive_flat_multimap(const recursive_flat_multimap &c)
+ : id_(c.id_), map_(c.map_)
+ {}
+
+ recursive_flat_multimap & operator =(const recursive_flat_multimap &c)
+ {
+ id_ = c.id_;
+ map_= c.map_;
+ return *this;
+ }
+ int id_;
+ flat_map<recursive_flat_multimap, recursive_flat_multimap> map_;
+ friend bool operator< (const recursive_flat_multimap &a, const recursive_flat_multimap &b)
+ { return a.id_ < b.id_; }
+};
+
+template<class C>
+void test_move()
+{
+ //Now test move semantics
+ C original;
+ C move_ctor(boost::move(original));
+ C move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+}
+
+int main()
+{
+ using namespace boost::container::test;
+
+ //Now test move semantics
+ {
+ test_move<flat_set<recursive_flat_set> >();
+ test_move<flat_multiset<recursive_flat_multiset> >();
+ test_move<flat_map<recursive_flat_map, recursive_flat_map> >();
+ test_move<flat_multimap<recursive_flat_multimap, recursive_flat_multimap> >();
+ }
+
+
+ if (0 != set_test<
+ MyBoostSet
+ ,MyStdSet
+ ,MyBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != set_test_copyable<
+ MyBoostSet
+ ,MyStdSet
+ ,MyBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != set_test<
+ MyMovableBoostSet
+ ,MyStdSet
+ ,MyMovableBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyMovableBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != set_test<
+ MyMoveCopyBoostSet
+ ,MyStdSet
+ ,MyMoveCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyMoveCopyBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != set_test_copyable<
+ MyMoveCopyBoostSet
+ ,MyStdSet
+ ,MyMoveCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != set_test<
+ MyCopyBoostSet
+ ,MyStdSet
+ ,MyCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyCopyBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != set_test_copyable<
+ MyCopyBoostSet
+ ,MyStdSet
+ ,MyCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+ return 1;
+ }
+
+ if (0 != map_test<
+ MyBoostMap
+ ,MyStdMap
+ ,MyBoostMultiMap
+ ,MyStdMultiMap>()){
+ std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+ return 1;
+ }
+
+ if (0 != map_test_copyable<
+ MyBoostMap
+ ,MyStdMap
+ ,MyBoostMultiMap
+ ,MyStdMultiMap>()){
+ std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+ return 1;
+ }
+
+// if (0 != map_test<
+// MyMovableBoostMap
+// ,MyStdMap
+// ,MyMovableBoostMultiMap
+// ,MyStdMultiMap>()){
+// return 1;
+// }
+
+ if (0 != map_test<
+ MyMoveCopyBoostMap
+ ,MyStdMap
+ ,MyMoveCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ std::cout << "Error in set_test<MyMoveCopyBoostMap>" << std::endl;
+ return 1;
+ }
+
+ if (0 != map_test_copyable<
+ MyMoveCopyBoostMap
+ ,MyStdMap
+ ,MyMoveCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+ return 1;
+ }
+
+ if (0 != map_test<
+ MyCopyBoostMap
+ ,MyStdMap
+ ,MyCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ std::cout << "Error in set_test<MyCopyBoostMap>" << std::endl;
+ return 1;
+ }
+
+ if (0 != map_test_copyable<
+ MyCopyBoostMap
+ ,MyStdMap
+ ,MyCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+ return 1;
+ }
+
+ const test::EmplaceOptions SetOptions = (test::EmplaceOptions)(test::EMPLACE_HINT | test::EMPLACE_ASSOC);
+ const test::EmplaceOptions MapOptions = (test::EmplaceOptions)(test::EMPLACE_HINT_PAIR | test::EMPLACE_ASSOC_PAIR);
+
+// if(!boost::container::test::test_emplace<flat_map<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+// return 1;
+ if(!boost::container::test::test_emplace<flat_multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+ return 1;
+ if(!boost::container::test::test_emplace<flat_set<test::EmplaceInt>, SetOptions>())
+ return 1;
+ if(!boost::container::test::test_emplace<flat_multiset<test::EmplaceInt>, SetOptions>())
+ return 1;
+ return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/heap_allocator_v1.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/heap_allocator_v1.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,159 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_HEAP_ALLOCATOR_V1_HPP
+#define BOOST_CONTAINER_HEAP_ALLOCATOR_V1_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <boost/pointer_to_other.hpp>
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/version_type.hpp>
+#include <boost/container/exceptions.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+
+//!\file
+//!Describes an heap_allocator_v1 that allocates portions of fixed size
+//!memory buffer (shared memory, mapped file...)
+
+namespace boost {
+namespace container {
+namespace test {
+
+//!An STL compatible heap_allocator_v1 that uses a segment manager as
+//!memory source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the heap_allocator_v1 in shared memory, memory mapped-files, etc...*/
+template<class T, class SegmentManager>
+class heap_allocator_v1
+{
+ private:
+ typedef heap_allocator_v1<T, SegmentManager> self_t;
+ typedef SegmentManager segment_manager;
+ typedef typename segment_manager::void_pointer aux_pointer_t;
+
+ typedef typename
+ boost::pointer_to_other
+ <aux_pointer_t, const void>::type cvoid_ptr;
+
+ typedef typename boost::pointer_to_other
+ <cvoid_ptr, segment_manager>::type alloc_ptr_t;
+
+ template<class T2, class SegmentManager2>
+ heap_allocator_v1& operator=(const heap_allocator_v1<T2, SegmentManager2>&);
+
+ heap_allocator_v1& operator=(const heap_allocator_v1&);
+
+ alloc_ptr_t mp_mngr;
+
+ public:
+ typedef T value_type;
+ typedef typename boost::pointer_to_other
+ <cvoid_ptr, T>::type pointer;
+ typedef typename boost::
+ pointer_to_other<pointer, const T>::type const_pointer;
+ typedef typename detail::add_reference
+ <value_type>::type reference;
+ typedef typename detail::add_reference
+ <const value_type>::type const_reference;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ //!Obtains an heap_allocator_v1 of other type
+ template<class T2>
+ struct rebind
+ {
+ typedef heap_allocator_v1<T2, SegmentManager> other;
+ };
+
+ //!Returns the segment manager. Never throws
+ segment_manager* get_segment_manager()const
+ { return detail::get_pointer(mp_mngr); }
+/*
+ //!Returns address of mutable object. Never throws
+ pointer address(reference value) const
+ { return pointer(addressof(value)); }
+
+ //!Returns address of non mutable object. Never throws
+ const_pointer address(const_reference value) const
+ { return const_pointer(addressof(value)); }
+*/
+ //!Constructor from the segment manager. Never throws
+ heap_allocator_v1(segment_manager *segment_mngr)
+ : mp_mngr(segment_mngr) { }
+
+ //!Constructor from other heap_allocator_v1. Never throws
+ heap_allocator_v1(const heap_allocator_v1 &other)
+ : mp_mngr(other.get_segment_manager()){ }
+
+ //!Constructor from related heap_allocator_v1. Never throws
+ template<class T2>
+ heap_allocator_v1(const heap_allocator_v1<T2, SegmentManager> &other)
+ : mp_mngr(other.get_segment_manager()){}
+
+ //!Allocates memory for an array of count elements.
+ //!Throws boost::container::bad_alloc if there is no enough memory
+ pointer allocate(size_type count, cvoid_ptr hint = 0)
+ { (void)hint; return ::new value_type[count]; }
+
+ //!Deallocates memory previously allocated. Never throws
+ void deallocate(const pointer &ptr, size_type)
+ { return ::delete[] detail::get_pointer(ptr) ; }
+
+ //!Construct object, calling constructor.
+ //!Throws if T(const T&) throws
+ void construct(const pointer &ptr, const_reference value)
+ { new((void*)detail::get_pointer(ptr)) value_type(value); }
+
+ //!Destroys object. Throws if object's destructor throws
+ void destroy(const pointer &ptr)
+ { BOOST_ASSERT(ptr != 0); (*ptr).~value_type(); }
+
+ //!Returns the number of elements that could be allocated. Never throws
+ size_type max_size() const
+ { return mp_mngr->get_size(); }
+
+ //!Swap segment manager. Does not throw. If each heap_allocator_v1 is placed in
+ //!different memory segments, the result is undefined.
+ friend void swap(self_t &alloc1, self_t &alloc2)
+ { detail::do_swap(alloc1.mp_mngr, alloc2.mp_mngr); }
+};
+
+//!Equality test for same type of heap_allocator_v1
+template<class T, class SegmentManager> inline
+bool operator==(const heap_allocator_v1<T , SegmentManager> &alloc1,
+ const heap_allocator_v1<T, SegmentManager> &alloc2)
+ { return alloc1.get_segment_manager() == alloc2.get_segment_manager(); }
+
+//!Inequality test for same type of heap_allocator_v1
+template<class T, class SegmentManager> inline
+bool operator!=(const heap_allocator_v1<T, SegmentManager> &alloc1,
+ const heap_allocator_v1<T, SegmentManager> &alloc2)
+ { return alloc1.get_segment_manager() != alloc2.get_segment_manager(); }
+
+} //namespace test {
+} //namespace container {
+} //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_HEAP_ALLOCATOR_V1_HPP
+

Added: trunk/libs/container/test/list_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/list_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,78 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/list.hpp>
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "list_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::list<test::movable_and_copyable_int,
+ test::dummy_test_allocator<test::movable_and_copyable_int> >;
+typedef list<int> MyList;
+
+typedef list<test::movable_int> MyMoveList;
+typedef list<test::movable_and_copyable_int> MyCopyMoveList;
+typedef list<test::copyable_int> MyCopyList;
+
+class recursive_list
+{
+public:
+ int id_;
+ list<recursive_list> list_;
+ recursive_list &operator=(const recursive_list &o)
+ { list_ = o.list_; return *this; }
+};
+
+void recursive_list_test()//Test for recursive types
+{
+ list<recursive_list> recursive, copy;
+ //Test to test both move emulations
+ if(!copy.size()){
+ copy = recursive;
+ }
+}
+
+int main ()
+{
+ recursive_list_test();
+ {
+ //Now test move semantics
+ list<recursive_list> original;
+ list<recursive_list> move_ctor(boost::move(original));
+ list<recursive_list> move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+ }
+ if(test::list_test<MyList, true>())
+ return 1;
+
+ if(test::list_test<MyMoveList, true>())
+ return 1;
+
+ if(test::list_test<MyCopyMoveList, true>())
+ return 1;
+
+ if(test::list_test<MyCopyList, true>())
+ return 1;
+
+ const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
+
+ if(!boost::container::test::test_emplace<list<test::EmplaceInt>, Options>())
+ return 1;
+
+ return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/list_test.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/list_test.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,312 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_LIST_TEST_HEADER
+#define BOOST_CONTAINER_TEST_LIST_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include <memory>
+#include <list>
+#include <vector>
+#include <functional>
+#include "print_container.hpp"
+#include <boost/move/move.hpp>
+#include <string>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class V1, class V2>
+bool list_copyable_only(V1 *, V2 *, boost::container::containers_detail::false_type)
+{
+ return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool list_copyable_only(V1 *boostlist, V2 *stdlist, boost::container::containers_detail::true_type)
+{
+ typedef typename V1::value_type IntType;
+ boostlist->insert(boostlist->end(), 50, IntType(1));
+ stdlist->insert(stdlist->end(), 50, 1);
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+
+ {
+ IntType move_me(1);
+ boostlist->insert(boostlist->begin(), 50, boost::move(move_me));
+ stdlist->insert(stdlist->begin(), 50, 1);
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+ }
+ {
+ IntType move_me(2);
+ boostlist->assign(boostlist->size()/2, boost::move(move_me));
+ stdlist->assign(stdlist->size()/2, 2);
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+ }
+ {
+ IntType move_me(3);
+ boostlist->assign(boostlist->size()*3-1, boost::move(move_me));
+ stdlist->assign(stdlist->size()*3-1, 3);
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+ }
+
+ {
+ IntType copy_me(3);
+ const IntType ccopy_me(3);
+ boostlist->push_front(copy_me);
+ stdlist->push_front(int(3));
+ boostlist->push_front(ccopy_me);
+ stdlist->push_front(int(3));
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+ }
+
+ return true;
+}
+
+template<bool DoublyLinked>
+struct list_push_data_function
+{
+ template<class MyBoostList, class MyStdList>
+ static int execute(int max, MyBoostList *boostlist, MyStdList *stdlist)
+ {
+ typedef typename MyBoostList::value_type IntType;
+ for(int i = 0; i < max; ++i){
+ IntType move_me(i);
+ boostlist->push_back(boost::move(move_me));
+ stdlist->push_back(i);
+ boostlist->push_front(IntType(i));
+ stdlist->push_front(int(i));
+ }
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+ return 0;
+ }
+};
+
+template<>
+struct list_push_data_function<false>
+{
+ template<class MyBoostList, class MyStdList>
+ static int execute(int max, MyBoostList *boostlist, MyStdList *stdlist)
+ {
+ typedef typename MyBoostList::value_type IntType;
+ for(int i = 0; i < max; ++i){
+ IntType move_me(i);
+ boostlist->push_front(boost::move(move_me));
+ stdlist->push_front(i);
+ boostlist->push_front(IntType(i));
+ stdlist->push_front(int(i));
+ }
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+ return 0;
+ }
+};
+
+template<bool DoublyLinked>
+struct list_pop_back_function
+{
+ template<class MyStdList, class MyBoostList>
+ static int execute(MyBoostList *boostlist, MyStdList *stdlist)
+ {
+ boostlist->pop_back();
+ stdlist->pop_back();
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+ return 0;
+ }
+};
+
+template<>
+struct list_pop_back_function<false>
+{
+ template<class MyStdList, class MyBoostList>
+ static int execute(MyBoostList *boostlist, MyStdList *stdlist)
+ {
+ (void)boostlist; (void)stdlist;
+ return 0;
+ }
+};
+
+template<class MyBoostList
+ ,bool DoublyLinked>
+int list_test (bool copied_allocators_equal = true)
+{
+ typedef std::list<int> MyStdList;
+ typedef typename MyBoostList::value_type IntType;
+ const int max = 100;
+ typedef list_push_data_function<DoublyLinked> push_data_t;
+
+ try{
+ MyBoostList *boostlist = new MyBoostList;
+ MyStdList *stdlist = new MyStdList;
+
+ if(push_data_t::execute(max, boostlist, stdlist)){
+ return 1;
+ }
+
+ boostlist->erase(boostlist->begin()++);
+ stdlist->erase(stdlist->begin()++);
+ if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+ if(list_pop_back_function<DoublyLinked>::execute(boostlist, stdlist)){
+ return 1;
+ }
+
+ boostlist->pop_front();
+ stdlist->pop_front();
+ if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ boostlist->assign(boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(&aux_vect[50]));
+ stdlist->assign(&aux_vect2[0], &aux_vect2[50]);
+ if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+ }
+
+ if(copied_allocators_equal){
+ boostlist->sort();
+ stdlist->sort();
+ if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+ }
+
+ boostlist->reverse();
+ stdlist->reverse();
+ if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+ boostlist->reverse();
+ stdlist->reverse();
+ if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ boostlist->insert(boostlist->begin()
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(&aux_vect[50]));
+ stdlist->insert(stdlist->begin(), &aux_vect2[0], &aux_vect2[50]);
+ }
+
+ boostlist->unique();
+ stdlist->unique();
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+
+ if(copied_allocators_equal){
+ boostlist->sort(std::greater<IntType>());
+ stdlist->sort(std::greater<int>());
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+ }
+
+ for(int i = 0; i < max; ++i){
+ IntType new_int(i);
+ boostlist->insert(boostlist->end(), boost::move(new_int));
+ stdlist->insert(stdlist->end(), i);
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+ }
+ if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+
+ boostlist->resize(25);
+ stdlist->resize(25);
+ boostlist->resize(50);
+ stdlist->resize(50);
+ boostlist->resize(0);
+ stdlist->resize(0);
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+
+ if(push_data_t::execute(max, boostlist, stdlist)){
+ return 1;
+ }
+ {
+ MyBoostList otherboostlist(boostlist->get_allocator());
+ MyStdList otherstdlist;
+
+ int listsize = (int)boostlist->size();
+
+ if(push_data_t::execute(listsize, boostlist, stdlist)){
+ return 1;
+ }
+
+ if(copied_allocators_equal){
+ boostlist->splice(boostlist->begin(), otherboostlist);
+ stdlist->splice(stdlist->begin(), otherstdlist);
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+ }
+
+ listsize = (int)boostlist->size();
+
+ if(push_data_t::execute(listsize, boostlist, stdlist)){
+ return 1;
+ }
+
+ if(push_data_t::execute(listsize, &otherboostlist, &otherstdlist)){
+ return 1;
+ }
+
+ if(copied_allocators_equal){
+ boostlist->sort(std::greater<IntType>());
+ stdlist->sort(std::greater<int>());
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+
+ otherboostlist.sort(std::greater<IntType>());
+ otherstdlist.sort(std::greater<int>());
+ if(!CheckEqualContainers(&otherboostlist, &otherstdlist))
+ return 1;
+
+ boostlist->merge(otherboostlist, std::greater<IntType>());
+ stdlist->merge(otherstdlist, std::greater<int>());
+ if(!CheckEqualContainers(boostlist, stdlist))
+ return 1;
+ }
+
+ if(!list_copyable_only(boostlist, stdlist
+ ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+ return 1;
+ }
+ }
+
+ delete boostlist;
+ delete stdlist;
+ }
+ catch(...){
+ throw;
+ }
+ return 0;
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif

Added: trunk/libs/container/test/map_test.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/map_test.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,521 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER
+#define BOOST_CONTAINER_TEST_MAP_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include <map>
+#include <functional>
+#include <utility>
+#include "print_container.hpp"
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/pair.hpp>
+#include <string>
+
+template<class T1, class T2, class T3, class T4>
+bool operator ==(std::pair<T1, T2> &p1, std::pair<T1, T2> &p2)
+{
+ return p1.first == p2.first && p1.second == p2.second;
+}
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class MyBoostMap
+ ,class MyStdMap
+ ,class MyBoostMultiMap
+ ,class MyStdMultiMap>
+int map_test ()
+{
+ typedef typename MyBoostMap::key_type IntType;
+ typedef containers_detail::pair<IntType, IntType> IntPairType;
+ typedef typename MyStdMap::value_type StdPairType;
+ const int max = 100;
+
+ try{
+ MyBoostMap *boostmap = new MyBoostMap;
+ MyStdMap *stdmap = new MyStdMap;
+ MyBoostMultiMap *boostmultimap = new MyBoostMultiMap;
+ MyStdMultiMap *stdmultimap = new MyStdMultiMap;
+
+ //Test construction from a range
+ {
+ //This is really nasty, but we have no other simple choice
+ IntPairType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(i/2);
+ IntType i2(i/2);
+ new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ typedef typename MyStdMap::value_type StdValueType;
+ typedef typename MyStdMap::key_type StdKeyType;
+ typedef typename MyStdMap::mapped_type StdMappedType;
+ StdValueType aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
+ }
+
+ IntPairType aux_vect3[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(i/2);
+ IntType i2(i/2);
+ new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ MyBoostMap *boostmap2 = new MyBoostMap
+ ( boost::make_move_iterator(&aux_vect[0])
+ , boost::make_move_iterator(aux_vect + 50));
+ MyStdMap *stdmap2 = new MyStdMap(aux_vect2, aux_vect2 + 50);
+ MyBoostMultiMap *boostmultimap2 = new MyBoostMultiMap
+ ( boost::make_move_iterator(&aux_vect3[0])
+ , boost::make_move_iterator(aux_vect3 + 50));
+ MyStdMultiMap *stdmultimap2 = new MyStdMultiMap(aux_vect2, aux_vect2 + 50);
+ if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
+ if(!CheckEqualContainers(boostmultimap2, stdmultimap2)) return 1;
+
+ //ordered range insertion
+ //This is really nasty, but we have no other simple choice
+ for(int i = 0; i < 50; ++i){
+ IntType i1(i);
+ IntType i2(i);
+ new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ for(int i = 0; i < 50; ++i){
+ new(&aux_vect2[i])StdValueType(StdKeyType(i), StdMappedType(i));
+ }
+
+ for(int i = 0; i < 50; ++i){
+ IntType i1(i);
+ IntType i2(i);
+ new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+/*
+ MyBoostMap *boostmap3 = new MyBoostMap
+ ( ordered_unique_range
+ , boost::make_move_iterator(&aux_vect[0])
+ , boost::make_move_iterator(aux_vect + 50));
+ MyStdMap *stdmap3 = new MyStdMap(aux_vect2, aux_vect2 + 50);
+ MyBoostMultiMap *boostmultimap3 = new MyBoostMultiMap
+ ( ordered_range
+ , boost::make_move_iterator(&aux_vect3[0])
+ , boost::make_move_iterator(aux_vect3 + 50));
+ MyStdMultiMap *stdmultimap3 = new MyStdMultiMap(aux_vect2, aux_vect2 + 50);
+
+ if(!CheckEqualContainers(boostmap3, stdmap3)){
+ std::cout << "Error in construct<MyBoostMap>(MyBoostMap3)" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultimap3, stdmultimap3)){
+ std::cout << "Error in construct<MyBoostMultiMap>(MyBoostMultiMap3)" << std::endl;
+ return 1;
+ }
+*/
+ delete boostmap2;
+ delete boostmultimap2;
+ delete stdmap2;
+ delete stdmultimap2;
+ //delete boostmap3;
+ //delete boostmultimap3;
+ //delete stdmap3;
+ //delete stdmultimap3;
+ }
+ {
+ //This is really nasty, but we have no other simple choice
+ IntPairType aux_vect[max];
+ for(int i = 0; i < max; ++i){
+ IntType i1(i);
+ IntType i2(i);
+ new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+ IntPairType aux_vect3[max];
+ for(int i = 0; i < max; ++i){
+ IntType i1(i);
+ IntType i2(i);
+ new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ for(int i = 0; i < max; ++i){
+ boostmap->insert(boost::move(aux_vect[i]));
+ stdmap->insert(StdPairType(i, i));
+ boostmultimap->insert(boost::move(aux_vect3[i]));
+ stdmultimap->insert(StdPairType(i, i));
+ }
+
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+ typename MyBoostMap::iterator it;
+ typename MyBoostMap::const_iterator cit = it;
+
+ boostmap->erase(boostmap->begin()++);
+ stdmap->erase(stdmap->begin()++);
+ boostmultimap->erase(boostmultimap->begin()++);
+ stdmultimap->erase(stdmultimap->begin()++);
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+ boostmap->erase(boostmap->begin());
+ stdmap->erase(stdmap->begin());
+ boostmultimap->erase(boostmultimap->begin());
+ stdmultimap->erase(stdmultimap->begin());
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+ //Swapping test
+ MyBoostMap tmpboostemap2;
+ MyStdMap tmpstdmap2;
+ MyBoostMultiMap tmpboostemultimap2;
+ MyStdMultiMap tmpstdmultimap2;
+ boostmap->swap(tmpboostemap2);
+ stdmap->swap(tmpstdmap2);
+ boostmultimap->swap(tmpboostemultimap2);
+ stdmultimap->swap(tmpstdmultimap2);
+ boostmap->swap(tmpboostemap2);
+ stdmap->swap(tmpstdmap2);
+ boostmultimap->swap(tmpboostemultimap2);
+ stdmultimap->swap(tmpstdmultimap2);
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+ }
+ //Insertion from other container
+ //Initialize values
+ {
+ //This is really nasty, but we have no other simple choice
+ IntPairType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(-1);
+ IntType i2(-1);
+ new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+ IntPairType aux_vect3[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(-1);
+ IntType i2(-1);
+ new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ boostmap->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+ boostmultimap->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+ for(std::size_t i = 0; i != 50; ++i){
+ StdPairType stdpairtype(-1, -1);
+ stdmap->insert(stdpairtype);
+ stdmultimap->insert(stdpairtype);
+ }
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+ for(int i = 0, j = static_cast<int>(boostmap->size()); i < j; ++i){
+ boostmap->erase(IntType(i));
+ stdmap->erase(i);
+ boostmultimap->erase(IntType(i));
+ stdmultimap->erase(i);
+ }
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+ }
+ {
+ IntPairType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(-1);
+ IntType i2(-1);
+ new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ IntPairType aux_vect3[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(-1);
+ IntType i2(-1);
+ new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ IntPairType aux_vect4[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(-1);
+ IntType i2(-1);
+ new(&aux_vect4[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ IntPairType aux_vect5[50];
+ for(int i = 0; i < 50; ++i){
+ IntType i1(-1);
+ IntType i2(-1);
+ new(&aux_vect5[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ boostmap->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+ boostmap->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+ boostmultimap->insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + 50));
+ boostmultimap->insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + 50));
+
+ for(std::size_t i = 0; i != 50; ++i){
+ StdPairType stdpairtype(-1, -1);
+ stdmap->insert(stdpairtype);
+ stdmultimap->insert(stdpairtype);
+ stdmap->insert(stdpairtype);
+ stdmultimap->insert(stdpairtype);
+ }
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+ boostmap->erase(boostmap->begin()->first);
+ stdmap->erase(stdmap->begin()->first);
+ boostmultimap->erase(boostmultimap->begin()->first);
+ stdmultimap->erase(stdmultimap->begin()->first);
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+ }
+
+ {
+ //This is really nasty, but we have no other simple choice
+ IntPairType aux_vect[max];
+ for(int i = 0; i < max; ++i){
+ IntType i1(i);
+ IntType i2(i);
+ new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+ IntPairType aux_vect3[max];
+ for(int i = 0; i < max; ++i){
+ IntType i1(i);
+ IntType i2(i);
+ new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+ }
+
+ for(int i = 0; i < max; ++i){
+ boostmap->insert(boost::move(aux_vect[i]));
+ stdmap->insert(StdPairType(i, i));
+ boostmultimap->insert(boost::move(aux_vect3[i]));
+ stdmultimap->insert(StdPairType(i, i));
+ }
+
+ if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+ for(int i = 0; i < max; ++i){
+ IntPairType intpair;
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmap->insert(boostmap->begin(), boost::move(intpair));
+ stdmap->insert(stdmap->begin(), StdPairType(i, i));
+ //PrintContainers(boostmap, stdmap);
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmultimap->insert(boostmultimap->begin(), boost::move(intpair));
+ stdmultimap->insert(stdmultimap->begin(), StdPairType(i, i));
+ //PrintContainers(boostmultimap, stdmultimap);
+ if(!CheckEqualPairContainers(boostmap, stdmap))
+ return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+ return 1;
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmap->insert(boostmap->end(), boost::move(intpair));
+ stdmap->insert(stdmap->end(), StdPairType(i, i));
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmultimap->insert(boostmultimap->end(), boost::move(intpair));
+ stdmultimap->insert(stdmultimap->end(), StdPairType(i, i));
+ if(!CheckEqualPairContainers(boostmap, stdmap))
+ return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+ return 1;
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmap->insert(boostmap->lower_bound(IntType(i)), boost::move(intpair));
+ stdmap->insert(stdmap->lower_bound(i), StdPairType(i, i));
+ //PrintContainers(boostmap, stdmap);
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ {
+ IntType i1(i);
+ boostmultimap->insert(boostmultimap->lower_bound(boost::move(i1)), boost::move(intpair));
+ stdmultimap->insert(stdmultimap->lower_bound(i), StdPairType(i, i));
+ }
+
+ //PrintContainers(boostmultimap, stdmultimap);
+ if(!CheckEqualPairContainers(boostmap, stdmap))
+ return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+ return 1;
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ {
+ IntType i1(i);
+ boostmap->insert(boostmap->upper_bound(boost::move(i1)), boost::move(intpair));
+ stdmap->insert(stdmap->upper_bound(i), StdPairType(i, i));
+ }
+ //PrintContainers(boostmap, stdmap);
+ {
+ IntType i1(i);
+ IntType i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ {
+ IntType i1(i);
+ boostmultimap->insert(boostmultimap->upper_bound(boost::move(i1)), boost::move(intpair));
+ stdmultimap->insert(stdmultimap->upper_bound(i), StdPairType(i, i));
+ }
+ //PrintContainers(boostmultimap, stdmultimap);
+ if(!CheckEqualPairContainers(boostmap, stdmap))
+ return 1;
+ if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+ return 1;
+ }
+
+ //Compare count with std containers
+ for(int i = 0; i < max; ++i){
+ if(boostmap->count(IntType(i)) != stdmap->count(i)){
+ return -1;
+ }
+
+ if(boostmultimap->count(IntType(i)) != stdmultimap->count(i)){
+ return -1;
+ }
+ }
+
+ //Now do count exercise
+ boostmap->erase(boostmap->begin(), boostmap->end());
+ boostmultimap->erase(boostmultimap->begin(), boostmultimap->end());
+ boostmap->clear();
+ boostmultimap->clear();
+
+ for(int j = 0; j < 3; ++j)
+ for(int i = 0; i < 100; ++i){
+ IntPairType intpair;
+ {
+ IntType i1(i), i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmap->insert(boost::move(intpair));
+ {
+ IntType i1(i), i2(i);
+ new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+ }
+ boostmultimap->insert(boost::move(intpair));
+ if(boostmap->count(IntType(i)) != typename MyBoostMultiMap::size_type(1))
+ return 1;
+ if(boostmultimap->count(IntType(i)) != typename MyBoostMultiMap::size_type(j+1))
+ return 1;
+ }
+ }
+
+ delete boostmap;
+ delete stdmap;
+ delete boostmultimap;
+ delete stdmultimap;
+ }
+ catch(...){
+ throw;
+ }
+ return 0;
+}
+
+template<class MyBoostMap
+ ,class MyStdMap
+ ,class MyBoostMultiMap
+ ,class MyStdMultiMap>
+int map_test_copyable ()
+{
+ typedef typename MyBoostMap::key_type IntType;
+ typedef containers_detail::pair<IntType, IntType> IntPairType;
+ typedef typename MyStdMap::value_type StdPairType;
+
+ const int max = 100;
+
+ try{
+ MyBoostMap *boostmap = new MyBoostMap;
+ MyStdMap *stdmap = new MyStdMap;
+ MyBoostMultiMap *boostmultimap = new MyBoostMultiMap;
+ MyStdMultiMap *stdmultimap = new MyStdMultiMap;
+
+ int i;
+ for(i = 0; i < max; ++i){
+ {
+ IntType i1(i), i2(i);
+ IntPairType intpair1(boost::move(i1), boost::move(i2));
+ boostmap->insert(boost::move(intpair1));
+ stdmap->insert(StdPairType(i, i));
+ }
+ {
+ IntType i1(i), i2(i);
+ IntPairType intpair2(boost::move(i1), boost::move(i2));
+ boostmultimap->insert(boost::move(intpair2));
+ stdmultimap->insert(StdPairType(i, i));
+ }
+ }
+ if(!CheckEqualContainers(boostmap, stdmap)) return 1;
+ if(!CheckEqualContainers(boostmultimap, stdmultimap)) return 1;
+
+ {
+ //Now, test copy constructor
+ MyBoostMap boostmapcopy(*boostmap);
+ MyStdMap stdmapcopy(*stdmap);
+ MyBoostMultiMap boostmmapcopy(*boostmultimap);
+ MyStdMultiMap stdmmapcopy(*stdmultimap);
+
+ if(!CheckEqualContainers(&boostmapcopy, &stdmapcopy))
+ return 1;
+ if(!CheckEqualContainers(&boostmmapcopy, &stdmmapcopy))
+ return 1;
+
+ //And now assignment
+ boostmapcopy = *boostmap;
+ stdmapcopy = *stdmap;
+ boostmmapcopy = *boostmultimap;
+ stdmmapcopy = *stdmultimap;
+
+ if(!CheckEqualContainers(&boostmapcopy, &stdmapcopy))
+ return 1;
+ if(!CheckEqualContainers(&boostmmapcopy, &stdmmapcopy))
+ return 1;
+ delete boostmap;
+ delete boostmultimap;
+ delete stdmap;
+ delete stdmultimap;
+ }
+ }
+ catch(...){
+ throw;
+ }
+ return 0;
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER

Added: trunk/libs/container/test/movable_int.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/movable_int.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,230 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
+#define BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/move/move.hpp>
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<class T>
+struct is_copyable;
+
+template<>
+struct is_copyable<int>
+{
+ static const bool value = true;
+};
+
+
+class movable_int
+{
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(movable_int)
+
+ public:
+ movable_int()
+ : m_int(0)
+ {}
+
+ explicit movable_int(int a)
+ : m_int(a)
+ {}
+
+ movable_int(BOOST_RV_REF(movable_int) mmi)
+ : m_int(mmi.m_int)
+ { mmi.m_int = 0; }
+
+ movable_int & operator= (BOOST_RV_REF(movable_int) mmi)
+ { this->m_int = mmi.m_int; mmi.m_int = 0; return *this; }
+
+ movable_int & operator= (int i)
+ { this->m_int = i; return *this; }
+
+ bool operator ==(const movable_int &mi) const
+ { return this->m_int == mi.m_int; }
+
+ bool operator !=(const movable_int &mi) const
+ { return this->m_int != mi.m_int; }
+
+ bool operator <(const movable_int &mi) const
+ { return this->m_int < mi.m_int; }
+
+ bool operator <=(const movable_int &mi) const
+ { return this->m_int <= mi.m_int; }
+
+ bool operator >=(const movable_int &mi) const
+ { return this->m_int >= mi.m_int; }
+
+ bool operator >(const movable_int &mi) const
+ { return this->m_int > mi.m_int; }
+
+ int get_int() const
+ { return m_int; }
+
+ private:
+ int m_int;
+};
+
+template<class E, class T>
+std::basic_ostream<E, T> & operator<<
+ (std::basic_ostream<E, T> & os, movable_int const & p)
+
+{
+ os << p.get_int();
+ return os;
+}
+
+
+template<>
+struct is_copyable<movable_int>
+{
+ static const bool value = false;
+};
+
+class movable_and_copyable_int
+{
+ BOOST_COPYABLE_AND_MOVABLE(movable_and_copyable_int)
+
+ public:
+ movable_and_copyable_int()
+ : m_int(0)
+ {}
+
+ explicit movable_and_copyable_int(int a)
+ : m_int(a)
+ {}
+
+ movable_and_copyable_int(const movable_and_copyable_int& mmi)
+ : m_int(mmi.m_int)
+ {}
+
+ movable_and_copyable_int(BOOST_RV_REF(movable_and_copyable_int) mmi)
+ : m_int(mmi.m_int)
+ { mmi.m_int = 0; }
+
+ movable_and_copyable_int &operator= (BOOST_COPY_ASSIGN_REF(movable_and_copyable_int) mi)
+ { this->m_int = mi.m_int; return *this; }
+
+ movable_and_copyable_int & operator= (BOOST_RV_REF(movable_and_copyable_int) mmi)
+ { this->m_int = mmi.m_int; mmi.m_int = 0; return *this; }
+
+ movable_and_copyable_int & operator= (int i)
+ { this->m_int = i; return *this; }
+
+ bool operator ==(const movable_and_copyable_int &mi) const
+ { return this->m_int == mi.m_int; }
+
+ bool operator !=(const movable_and_copyable_int &mi) const
+ { return this->m_int != mi.m_int; }
+
+ bool operator <(const movable_and_copyable_int &mi) const
+ { return this->m_int < mi.m_int; }
+
+ bool operator <=(const movable_and_copyable_int &mi) const
+ { return this->m_int <= mi.m_int; }
+
+ bool operator >=(const movable_and_copyable_int &mi) const
+ { return this->m_int >= mi.m_int; }
+
+ bool operator >(const movable_and_copyable_int &mi) const
+ { return this->m_int > mi.m_int; }
+
+ int get_int() const
+ { return m_int; }
+
+ private:
+ int m_int;
+};
+
+template<class E, class T>
+std::basic_ostream<E, T> & operator<<
+ (std::basic_ostream<E, T> & os, movable_and_copyable_int const & p)
+
+{
+ os << p.get_int();
+ return os;
+}
+
+template<>
+struct is_copyable<movable_and_copyable_int>
+{
+ static const bool value = true;
+};
+
+class copyable_int
+{
+ public:
+ copyable_int()
+ : m_int(0)
+ {}
+
+ explicit copyable_int(int a)
+ : m_int(a)
+ {}
+
+ copyable_int(const copyable_int& mmi)
+ : m_int(mmi.m_int)
+ {}
+
+ copyable_int & operator= (int i)
+ { this->m_int = i; return *this; }
+
+ bool operator ==(const copyable_int &mi) const
+ { return this->m_int == mi.m_int; }
+
+ bool operator !=(const copyable_int &mi) const
+ { return this->m_int != mi.m_int; }
+
+ bool operator <(const copyable_int &mi) const
+ { return this->m_int < mi.m_int; }
+
+ bool operator <=(const copyable_int &mi) const
+ { return this->m_int <= mi.m_int; }
+
+ bool operator >=(const copyable_int &mi) const
+ { return this->m_int >= mi.m_int; }
+
+ bool operator >(const copyable_int &mi) const
+ { return this->m_int > mi.m_int; }
+
+ int get_int() const
+ { return m_int; }
+
+ private:
+ int m_int;
+};
+
+template<class E, class T>
+std::basic_ostream<E, T> & operator<<
+ (std::basic_ostream<E, T> & os, copyable_int const & p)
+
+{
+ os << p.get_int();
+ return os;
+}
+
+template<>
+struct is_copyable<copyable_int>
+{
+ static const bool value = true;
+};
+
+} //namespace test {
+} //namespace container {
+} //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER

Added: trunk/libs/container/test/print_container.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/print_container.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,64 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_PRINTCONTAINER_HPP
+#define BOOST_PRINTCONTAINER_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <functional>
+#include <iostream>
+#include <algorithm>
+
+namespace boost{
+namespace container {
+namespace test{
+
+struct PrintValues : public std::unary_function<int, void>
+{
+ void operator() (int value) const
+ {
+ std::cout << value << " ";
+ }
+};
+
+template<class Container>
+void PrintContents(const Container &cont, const char *contName)
+{
+ std::cout<< "Printing contents of " << contName << std::endl;
+ std::for_each(cont.begin(), cont.end(), PrintValues());
+ std::cout<< std::endl << std::endl;
+}
+
+//Function to dump data
+template<class MyBoostCont
+ ,class MyStdCont>
+void PrintContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+ typename MyBoostCont::iterator itboost = boostcont->begin(), itboostend = boostcont->end();
+ typename MyStdCont::iterator itstd = stdcont->begin(), itstdend = stdcont->end();
+
+ std::cout << "MyBoostCont" << std::endl;
+ for(; itboost != itboostend; ++itboost){
+ std::cout << *itboost << std::endl;
+ }
+ std::cout << "MyStdCont" << std::endl;
+
+ for(; itstd != itstdend; ++itstd){
+ std::cout << *itstd << std::endl;
+ }
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_PRINTCONTAINER_HPP

Added: trunk/libs/container/test/set_test.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/set_test.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,504 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_SET_TEST_HEADER
+#define BOOST_CONTAINER_TEST_SET_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include <memory>
+#include <set>
+#include <functional>
+#include "print_container.hpp"
+#include <boost/move/move.hpp>
+#include <string>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class MyBoostSet
+ ,class MyStdSet
+ ,class MyBoostMultiSet
+ ,class MyStdMultiSet>
+int set_test ()
+{
+ typedef typename MyBoostSet::value_type IntType;
+ const int max = 100;
+
+ //Shared memory allocator must be always be initialized
+ //since it has no default constructor
+ MyBoostSet *boostset = new MyBoostSet;
+ MyStdSet *stdset = new MyStdSet;
+ MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
+ MyStdMultiSet *stdmultiset = new MyStdMultiSet;
+
+ //Test construction from a range
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(i/2);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = i/2;
+ }
+ IntType aux_vect3[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(i/2);
+ aux_vect3[i] = boost::move(move_me);
+ }
+
+ MyBoostSet *boostset2 = new MyBoostSet
+ ( boost::make_move_iterator(&aux_vect[0])
+ , boost::make_move_iterator(aux_vect + 50));
+ MyStdSet *stdset2 = new MyStdSet(aux_vect2, aux_vect2 + 50);
+ MyBoostMultiSet *boostmultiset2 = new MyBoostMultiSet
+ ( boost::make_move_iterator(&aux_vect3[0])
+ , boost::make_move_iterator(aux_vect3 + 50));
+ MyStdMultiSet *stdmultiset2 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
+ if(!CheckEqualContainers(boostset2, stdset2)){
+ std::cout << "Error in construct<MyBoostSet>(MyBoostSet2)" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset2, stdmultiset2)){
+ std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet2)" << std::endl;
+ return 1;
+ }
+
+ //ordered range insertion
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(i);
+ aux_vect[i] = boost::move(move_me);
+ }
+
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = i;
+ }
+
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(i);
+ aux_vect3[i] = boost::move(move_me);
+ }
+/*
+ MyBoostSet *boostset3 = MyBoostSet
+ ( ordered_unique_range
+ , boost::make_move_iterator(&aux_vect[0])
+ , boost::make_move_iterator(aux_vect + 50));
+ MyStdSet *stdset3 = new MyStdSet(aux_vect2, aux_vect2 + 50);
+ MyBoostMultiSet *boostmultiset3 = MyBoostMultiSet
+ ( ordered_range
+ , boost::make_move_iterator(&aux_vect3[0])
+ , boost::make_move_iterator(aux_vect3 + 50));
+ MyStdMultiSet *stdmultiset3 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
+
+ if(!CheckEqualContainers(boostset3, stdset3)){
+ std::cout << "Error in construct<MyBoostSet>(MyBoostSet3)" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset3, stdmultiset3)){
+ std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet3)" << std::endl;
+ return 1;
+ }
+*/
+ delete boostset2;
+ delete boostmultiset2;
+ delete stdset2;
+ delete stdmultiset2;
+ //delete boostset3;
+ //delete boostmultiset3;
+ //delete stdset3;
+ //delete stdmultiset3;
+ }
+
+ int i, j;
+ for(i = 0; i < max; ++i){
+ IntType move_me(i);
+ boostset->insert(boost::move(move_me));
+ stdset->insert(i);
+ boostset->insert(IntType(i));
+ stdset->insert(i);
+ IntType move_me2(i);
+ boostmultiset->insert(boost::move(move_me2));
+ stdmultiset->insert(i);
+ boostmultiset->insert(IntType(i));
+ stdmultiset->insert(i);
+ }
+
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boost::move(move_me)" << std::endl;
+ return 1;
+ }
+
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boost::move(move_me)" << std::endl;
+ return 1;
+ }
+
+ typename MyBoostSet::iterator it;
+ typename MyBoostSet::const_iterator cit = it;
+
+ boostset->erase(boostset->begin()++);
+ stdset->erase(stdset->begin()++);
+ boostmultiset->erase(boostmultiset->begin()++);
+ stdmultiset->erase(stdmultiset->begin()++);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->erase(boostset->begin()++)" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->erase(boostmultiset->begin()++)" << std::endl;
+ return 1;
+ }
+
+ boostset->erase(boostset->begin());
+ stdset->erase(stdset->begin());
+ boostmultiset->erase(boostmultiset->begin());
+ stdmultiset->erase(stdmultiset->begin());
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->erase(boostset->begin())" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->erase(boostmultiset->begin())" << std::endl;
+ return 1;
+ }
+
+ //Swapping test
+ MyBoostSet tmpboosteset2;
+ MyStdSet tmpstdset2;
+ MyBoostMultiSet tmpboostemultiset2;
+ MyStdMultiSet tmpstdmultiset2;
+ boostset->swap(tmpboosteset2);
+ stdset->swap(tmpstdset2);
+ boostmultiset->swap(tmpboostemultiset2);
+ stdmultiset->swap(tmpstdmultiset2);
+ boostset->swap(tmpboosteset2);
+ stdset->swap(tmpstdset2);
+ boostmultiset->swap(tmpboostemultiset2);
+ stdmultiset->swap(tmpstdmultiset2);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->swap(tmpboosteset2)" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->swap(tmpboostemultiset2)" << std::endl;
+ return 1;
+ }
+
+ //Insertion from other container
+ //Initialize values
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ IntType aux_vect3[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect3[i] = boost::move(move_me);
+ }
+
+ boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+ stdset->insert(aux_vect2, aux_vect2 + 50);
+ boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+ stdmultiset->insert(aux_vect2, aux_vect2 + 50);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect[0])..." << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), ..." << std::endl;
+ return 1;
+ }
+
+ for(int i = 0, j = static_cast<int>(boostset->size()); i < j; ++i){
+ IntType erase_me(i);
+ boostset->erase(erase_me);
+ stdset->erase(i);
+ boostmultiset->erase(erase_me);
+ stdmultiset->erase(i);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->erase(erase_me)" << boostset->size() << " " << stdset->size() << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->erase(erase_me)" << std::endl;
+ return 1;
+ }
+ }
+ }
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect[i] = boost::move(move_me);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ IntType aux_vect3[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect3[i] = boost::move(move_me);
+ }
+
+ IntType aux_vect4[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect4[i] = boost::move(move_me);
+ }
+
+ IntType aux_vect5[50];
+ for(int i = 0; i < 50; ++i){
+ IntType move_me(-1);
+ aux_vect5[i] = boost::move(move_me);
+ }
+
+ boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+ boostset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+ stdset->insert(aux_vect2, aux_vect2 + 50);
+ stdset->insert(aux_vect2, aux_vect2 + 50);
+ boostmultiset->insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + 50));
+ boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + 50));
+ stdmultiset->insert(aux_vect2, aux_vect2 + 50);
+ stdmultiset->insert(aux_vect2, aux_vect2 + 50);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0])..." << std::endl;
+ return 1;
+ }
+
+ boostset->erase(*boostset->begin());
+ stdset->erase(*stdset->begin());
+ boostmultiset->erase(*boostmultiset->begin());
+ stdmultiset->erase(*stdmultiset->begin());
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->erase(*boostset->begin())" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->erase(*boostmultiset->begin())" << std::endl;
+ return 1;
+ }
+ }
+
+ for(i = 0; i < max; ++i){
+ IntType move_me(i);
+ boostset->insert(boost::move(move_me));
+ stdset->insert(i);
+ IntType move_me2(i);
+ boostmultiset->insert(boost::move(move_me2));
+ stdmultiset->insert(i);
+ }
+
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boost::move(move_me)) try 2" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boost::move(move_me2)) try 2" << std::endl;
+ return 1;
+ }
+
+ for(i = 0; i < max; ++i){
+ IntType move_me(i);
+ boostset->insert(boostset->begin(), boost::move(move_me));
+ stdset->insert(stdset->begin(), i);
+ //PrintContainers(boostset, stdset);
+ IntType move_me2(i);
+ boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2));
+ stdmultiset->insert(stdmultiset->begin(), i);
+ //PrintContainers(boostmultiset, stdmultiset);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boostset->begin(), boost::move(move_me))" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2))" << std::endl;
+ return 1;
+ }
+
+ IntType move_me3(i);
+ boostset->insert(boostset->end(), boost::move(move_me3));
+ stdset->insert(stdset->end(), i);
+ IntType move_me4(i);
+ boostmultiset->insert(boostmultiset->end(), boost::move(move_me4));
+ stdmultiset->insert(stdmultiset->end(), i);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boostset->end(), boost::move(move_me3))" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boostmultiset->end(), boost::move(move_me4))" << std::endl;
+ return 1;
+ }
+ {
+ IntType move_me(i);
+ boostset->insert(boostset->upper_bound(move_me), boost::move(move_me));
+ stdset->insert(stdset->upper_bound(i), i);
+ //PrintContainers(boostset, stdset);
+ IntType move_me2(i);
+ boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2));
+ stdmultiset->insert(stdmultiset->upper_bound(i), i);
+ //PrintContainers(boostmultiset, stdmultiset);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boostset->upper_bound(move_me), boost::move(move_me))" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2))" << std::endl;
+ return 1;
+ }
+
+ }
+ {
+ IntType move_me(i);
+ boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2));
+ stdset->insert(stdset->lower_bound(i), i);
+ //PrintContainers(boostset, stdset);
+ IntType move_me2(i);
+ boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2));
+ stdmultiset->insert(stdmultiset->lower_bound(i), i);
+ //PrintContainers(boostmultiset, stdmultiset);
+ if(!CheckEqualContainers(boostset, stdset)){
+ std::cout << "Error in boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2))" << std::endl;
+ return 1;
+ }
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+ std::cout << "Error in boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2))" << std::endl;
+ return 1;
+ }
+ }
+ }
+
+ //Compare count with std containers
+ for(i = 0; i < max; ++i){
+ IntType count_me(i);
+ if(boostset->count(count_me) != stdset->count(i)){
+ return -1;
+ }
+ if(boostmultiset->count(count_me) != stdmultiset->count(i)){
+ return -1;
+ }
+ }
+
+ //Now do count exercise
+ boostset->erase(boostset->begin(), boostset->end());
+ boostmultiset->erase(boostmultiset->begin(), boostmultiset->end());
+ boostset->clear();
+ boostmultiset->clear();
+
+ for(j = 0; j < 3; ++j)
+ for(i = 0; i < 100; ++i){
+ IntType move_me(i);
+ boostset->insert(boost::move(move_me));
+ IntType move_me2(i);
+ boostmultiset->insert(boost::move(move_me2));
+ IntType count_me(i);
+ if(boostset->count(count_me) != typename MyBoostMultiSet::size_type(1)){
+ std::cout << "Error in boostset->count(count_me)" << std::endl;
+ return 1;
+ }
+ if(boostmultiset->count(count_me) != typename MyBoostMultiSet::size_type(j+1)){
+ std::cout << "Error in boostmultiset->count(count_me)" << std::endl;
+ return 1;
+ }
+ }
+
+ delete boostset;
+ delete stdset;
+ delete boostmultiset;
+ delete stdmultiset;
+ return 0;
+}
+
+template<class MyBoostSet
+ ,class MyStdSet
+ ,class MyBoostMultiSet
+ ,class MyStdMultiSet>
+int set_test_copyable ()
+{
+ typedef typename MyBoostSet::value_type IntType;
+ const int max = 100;
+
+ try{
+ //Shared memory allocator must be always be initialized
+ //since it has no default constructor
+ MyBoostSet *boostset = new MyBoostSet;
+ MyStdSet *stdset = new MyStdSet;
+ MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
+ MyStdMultiSet *stdmultiset = new MyStdMultiSet;
+
+ int i;
+ for(i = 0; i < max; ++i){
+ IntType move_me(i);
+ boostset->insert(boost::move(move_me));
+ stdset->insert(i);
+ IntType move_me2(i);
+ boostmultiset->insert(boost::move(move_me2));
+ stdmultiset->insert(i);
+ }
+ if(!CheckEqualContainers(boostset, stdset)) return 1;
+ if(!CheckEqualContainers(boostmultiset, stdmultiset)) return 1;
+
+ {
+ //Now, test copy constructor
+ MyBoostSet boostsetcopy(*boostset);
+ MyStdSet stdsetcopy(*stdset);
+
+ if(!CheckEqualContainers(&boostsetcopy, &stdsetcopy))
+ return 1;
+
+ MyBoostMultiSet boostmsetcopy(*boostmultiset);
+ MyStdMultiSet stdmsetcopy(*stdmultiset);
+
+ if(!CheckEqualContainers(&boostmsetcopy, &stdmsetcopy))
+ return 1;
+
+ //And now assignment
+ boostsetcopy = *boostset;
+ stdsetcopy = *stdset;
+
+ if(!CheckEqualContainers(&boostsetcopy, &stdsetcopy))
+ return 1;
+
+ boostmsetcopy = *boostmultiset;
+ stdmsetcopy = *stdmultiset;
+
+ if(!CheckEqualContainers(&boostmsetcopy, &stdmsetcopy))
+ return 1;
+ }
+ delete boostset;
+ delete boostmultiset;
+ }
+ catch(...){
+ throw;
+ }
+ return 0;
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif

Added: trunk/libs/container/test/slist_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/slist_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,82 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/slist.hpp>
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "list_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::slist<test::movable_and_copyable_int,
+ test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+typedef slist<int> MyList;
+typedef slist<test::movable_int> MyMoveList;
+typedef slist<test::movable_and_copyable_int> MyCopyMoveList;
+typedef slist<test::copyable_int> MyCopyList;
+
+class recursive_slist
+{
+public:
+ int id_;
+ slist<recursive_slist> slist_;
+ recursive_slist &operator=(const recursive_slist &o)
+ { slist_ = o.slist_; return *this; }
+};
+
+void recursive_slist_test()//Test for recursive types
+{
+ slist<recursive_slist> recursive_list_list;
+}
+
+int main ()
+{
+ recursive_slist_test();
+ {
+ //Now test move semantics
+ slist<recursive_slist> original;
+ slist<recursive_slist> move_ctor(boost::move(original));
+ slist<recursive_slist> move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+ {
+ slist<recursive_slist> recursive, copy;
+ //Test to test both move emulations
+ if(!copy.size()){
+ copy = recursive;
+ }
+ }
+ }
+
+ if(test::list_test<MyList, false>())
+ return 1;
+
+ if(test::list_test<MyMoveList, false>())
+ return 1;
+
+ if(test::list_test<MyCopyMoveList, false>())
+ return 1;
+
+ if(test::list_test<MyCopyList, false>())
+ return 1;
+
+ const test::EmplaceOptions Options = (test::EmplaceOptions)
+ (test::EMPLACE_FRONT | test::EMPLACE_AFTER | test::EMPLACE_BEFORE | test::EMPLACE_AFTER);
+
+ if(!boost::container::test::test_emplace
+ < slist<test::EmplaceInt>, Options>())
+ return 1;
+}
+
+#include <boost/container/detail/config_end.hpp>
+

Added: trunk/libs/container/test/stable_vector_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/stable_vector_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <functional>
+
+#include <boost/container/stable_vector.hpp>
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "dummy_test_allocator.hpp"
+#include "vector_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+//template class stable_vector<test::movable_and_copyable_int,
+ //test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+class recursive_vector
+{
+ public:
+ int id_;
+ stable_vector<recursive_vector> vector_;
+ recursive_vector &operator=(const recursive_vector &o)
+ { vector_ = o.vector_; return *this; }
+};
+
+void recursive_vector_test()//Test for recursive types
+{
+ stable_vector<recursive_vector> recursive, copy;
+ //Test to test both move emulations
+ if(!copy.size()){
+ copy = recursive;
+ }
+}
+
+int main()
+{
+ recursive_vector_test();
+ {
+ //Now test move semantics
+ stable_vector<recursive_vector> original;
+ stable_vector<recursive_vector> move_ctor(boost::move(original));
+ stable_vector<recursive_vector> move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+ }
+ typedef stable_vector<int> MyVector;
+ typedef stable_vector<test::movable_int> MyMoveVector;
+ typedef stable_vector<test::movable_and_copyable_int> MyCopyMoveVector;
+ typedef stable_vector<test::copyable_int> MyCopyVector;
+
+ if(test::vector_test<MyVector>())
+ return 1;
+
+ if(test::vector_test<MyMoveVector>())
+ return 1;
+
+ if(test::vector_test<MyCopyMoveVector>())
+ return 1;
+
+ if(test::vector_test<MyCopyVector>())
+ return 1;
+
+ const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+ if(!boost::container::test::test_emplace
+ < stable_vector<test::EmplaceInt>, Options>())
+ return 1;
+
+ return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/string_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/string_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,293 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/string.hpp>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cstring>
+#include <cstdio>
+#include <cstddef>
+#include <new>
+#include "dummy_test_allocator.hpp"
+#include "check_equal_containers.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+
+using namespace boost::container;
+
+typedef test::dummy_test_allocator<char> DummyCharAllocator;
+typedef basic_string<char, std::char_traits<char>, DummyCharAllocator> DummyString;
+typedef test::dummy_test_allocator<DummyString> DummyStringAllocator;
+typedef test::dummy_test_allocator<wchar_t> DummyWCharAllocator;
+typedef basic_string<wchar_t, std::char_traits<wchar_t>, DummyWCharAllocator> DummyWString;
+typedef test::dummy_test_allocator<DummyWString> DummyWStringAllocator;
+
+//Explicit instantiations of container::basic_string
+template class basic_string<char, std::char_traits<char>, DummyCharAllocator>;
+template class basic_string<wchar_t, std::char_traits<wchar_t>, DummyWCharAllocator>;
+//Explicit instantiation of container::vectors of container::strings
+template class vector<DummyString, DummyStringAllocator>;
+template class vector<DummyWString, DummyWStringAllocator>;
+
+struct StringEqual
+{
+ template<class Str1, class Str2>
+ bool operator ()(const Str1 &string1, const Str2 &string2) const
+ {
+ if(string1.size() != string2.size())
+ return false;
+ return std::char_traits<typename Str1::value_type>::compare
+ (string1.c_str(), string2.c_str(), string1.size()) == 0;
+ }
+};
+
+//Function to check if both lists are equal
+template<class StrVector1, class StrVector2>
+bool CheckEqualStringVector(StrVector1 *strvect1, StrVector2 *strvect2)
+{
+ StringEqual comp;
+ return std::equal(strvect1->begin(), strvect1->end(),
+ strvect2->begin(), comp);
+}
+
+template<class CharType>
+int string_test()
+{
+ typedef std::string StdString;
+ typedef vector<StdString> StdStringVector;
+ typedef basic_string<CharType> BoostString;
+ typedef vector<BoostString> BoostStringVector;
+
+ const int MaxSize = 100;
+
+ //Create shared memory
+ {
+ BoostStringVector *boostStringVect = new BoostStringVector;
+ StdStringVector *stdStringVect = new StdStringVector;
+ BoostString auxBoostString;
+ StdString auxStdString(StdString(auxBoostString.begin(), auxBoostString.end() ));
+
+ CharType buffer [20];
+
+ //First, push back
+ for(int i = 0; i < MaxSize; ++i){
+ auxBoostString = "String";
+ auxStdString = "String";
+ std::sprintf(buffer, "%i", i);
+ auxBoostString += buffer;
+ auxStdString += buffer;
+ boostStringVect->push_back(auxBoostString);
+ stdStringVect->push_back(auxStdString);
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+ return 1;
+ }
+
+ //Now push back moving
+ for(int i = 0; i < MaxSize; ++i){
+ auxBoostString = "String";
+ auxStdString = "String";
+ std::sprintf(buffer, "%i", i);
+ auxBoostString += buffer;
+ auxStdString += buffer;
+ boostStringVect->push_back(boost::move(auxBoostString));
+ stdStringVect->push_back(auxStdString);
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+ return 1;
+ }
+
+ //push front
+ for(int i = 0; i < MaxSize; ++i){
+ auxBoostString = "String";
+ auxStdString = "String";
+ std::sprintf(buffer, "%i", i);
+ auxBoostString += buffer;
+ auxStdString += buffer;
+ boostStringVect->insert(boostStringVect->begin(), auxBoostString);
+ stdStringVect->insert(stdStringVect->begin(), auxStdString);
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+ return 1;
+ }
+
+ //Now push front moving
+ for(int i = 0; i < MaxSize; ++i){
+ auxBoostString = "String";
+ auxStdString = "String";
+ std::sprintf(buffer, "%i", i);
+ auxBoostString += buffer;
+ auxStdString += buffer;
+ boostStringVect->insert(boostStringVect->begin(), boost::move(auxBoostString));
+ stdStringVect->insert(stdStringVect->begin(), auxStdString);
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+ return 1;
+ }
+
+ //Now test long and short representation swapping
+
+ //Short first
+ auxBoostString = "String";
+ auxStdString = "String";
+ BoostString boost_swapper;
+ StdString std_swapper;
+ boost_swapper.swap(auxBoostString);
+ std_swapper.swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+ if(!StringEqual()(boost_swapper, std_swapper))
+ return 1;
+ boost_swapper.swap(auxBoostString);
+ std_swapper.swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+ if(!StringEqual()(boost_swapper, std_swapper))
+ return 1;
+
+ //Shrink_to_fit
+ auxBoostString.shrink_to_fit();
+ StdString(auxStdString).swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+
+ //Reserve + shrink_to_fit
+ auxBoostString.reserve(boost_swapper.size()*2+1);
+ auxStdString.reserve(std_swapper.size()*2+1);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+
+ auxBoostString.shrink_to_fit();
+ StdString(auxStdString).swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+
+ //Long string
+ auxBoostString = "LongLongLongLongLongLongLongLongLongLongLongLongLongString";
+ auxStdString = "LongLongLongLongLongLongLongLongLongLongLongLongLongString";
+ boost_swapper = BoostString();
+ std_swapper = StdString();
+ boost_swapper.swap(auxBoostString);
+ std_swapper.swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+ if(!StringEqual()(boost_swapper, std_swapper))
+ return 1;
+ boost_swapper.swap(auxBoostString);
+ std_swapper.swap(auxStdString);
+
+ //Shrink_to_fit
+ auxBoostString.shrink_to_fit();
+ StdString(auxStdString).swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+
+ auxBoostString.clear();
+ auxStdString.clear();
+ auxBoostString.shrink_to_fit();
+ StdString(auxStdString).swap(auxStdString);
+ if(!StringEqual()(auxBoostString, auxStdString))
+ return 1;
+
+ //No sort
+ std::sort(boostStringVect->begin(), boostStringVect->end());
+ std::sort(stdStringVect->begin(), stdStringVect->end());
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ const CharType prefix [] = "Prefix";
+ const int prefix_size = sizeof(prefix)/sizeof(prefix[0])-1;
+ const CharType sufix [] = "Suffix";
+
+ for(int i = 0; i < MaxSize; ++i){
+ (*boostStringVect)[i].append(sufix);
+ (*stdStringVect)[i].append(sufix);
+ (*boostStringVect)[i].insert((*boostStringVect)[i].begin(),
+ prefix, prefix + prefix_size);
+ (*stdStringVect)[i].insert((*stdStringVect)[i].begin(),
+ prefix, prefix + prefix_size);
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ for(int i = 0; i < MaxSize; ++i){
+ std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
+ std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ for(int i = 0; i < MaxSize; ++i){
+ std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
+ std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ for(int i = 0; i < MaxSize; ++i){
+ std::sort(boostStringVect->begin(), boostStringVect->end());
+ std::sort(stdStringVect->begin(), stdStringVect->end());
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ for(int i = 0; i < MaxSize; ++i){
+ (*boostStringVect)[i].replace((*boostStringVect)[i].begin(),
+ (*boostStringVect)[i].end(),
+ "String");
+ (*stdStringVect)[i].replace((*stdStringVect)[i].begin(),
+ (*stdStringVect)[i].end(),
+ "String");
+ }
+
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ boostStringVect->erase(std::unique(boostStringVect->begin(), boostStringVect->end()),
+ boostStringVect->end());
+ stdStringVect->erase(std::unique(stdStringVect->begin(), stdStringVect->end()),
+ stdStringVect->end());
+ if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+ //When done, delete vector
+ delete boostStringVect;
+ delete stdStringVect;
+ }
+ return 0;
+}
+
+bool test_expand_bwd()
+{
+ //Now test all back insertion possibilities
+ typedef test::expand_bwd_test_allocator<char>
+ allocator_type;
+ typedef basic_string<char, std::char_traits<char>, allocator_type>
+ string_type;
+ return test::test_all_expand_bwd<string_type>();
+}
+
+int main()
+{
+ if(string_test<char>()){
+ return 1;
+ }
+
+ if(!test_expand_bwd())
+ return 1;
+
+ return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/tree_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/tree_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,233 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <set>
+#include <boost/container/set.hpp>
+#include <boost/container/map.hpp>
+#include "print_container.hpp"
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+#include "set_test.hpp"
+#include "map_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Alias standard types
+typedef std::set<int> MyStdSet;
+typedef std::multiset<int> MyStdMultiSet;
+typedef std::map<int, int> MyStdMap;
+typedef std::multimap<int, int> MyStdMultiMap;
+
+//Alias non-movable types
+typedef set<int> MyBoostSet;
+typedef multiset<int> MyBoostMultiSet;
+typedef map<int, int> MyBoostMap;
+typedef multimap<int, int> MyBoostMultiMap;
+
+//Alias movable types
+typedef set<test::movable_int> MyMovableBoostSet;
+typedef multiset<test::movable_int> MyMovableBoostMultiSet;
+typedef map<test::movable_int, test::movable_int> MyMovableBoostMap;
+typedef multimap<test::movable_int, test::movable_int> MyMovableBoostMultiMap;
+typedef set<test::movable_and_copyable_int> MyMoveCopyBoostSet;
+typedef set<test::copyable_int> MyCopyBoostSet;
+typedef multiset<test::movable_and_copyable_int> MyMoveCopyBoostMultiSet;
+typedef multiset<test::copyable_int> MyCopyBoostMultiSet;
+typedef map<test::movable_and_copyable_int
+ ,test::movable_and_copyable_int> MyMoveCopyBoostMap;
+typedef multimap<test::movable_and_copyable_int
+ ,test::movable_and_copyable_int> MyMoveCopyBoostMultiMap;
+typedef map<test::copyable_int
+ ,test::copyable_int> MyCopyBoostMap;
+typedef multimap<test::copyable_int
+ ,test::copyable_int> MyCopyBoostMultiMap;
+//Test recursive structures
+class recursive_set
+{
+public:
+ int id_;
+ set<recursive_set> set_;
+ friend bool operator< (const recursive_set &a, const recursive_set &b)
+ { return a.id_ < b.id_; }
+};
+
+class recursive_map
+{
+ public:
+ int id_;
+ map<recursive_map, recursive_map> map_;
+ friend bool operator< (const recursive_map &a, const recursive_map &b)
+ { return a.id_ < b.id_; }
+};
+
+//Test recursive structures
+class recursive_multiset
+{
+public:
+ int id_;
+ multiset<recursive_multiset> multiset_;
+ friend bool operator< (const recursive_multiset &a, const recursive_multiset &b)
+ { return a.id_ < b.id_; }
+};
+
+class recursive_multimap
+{
+public:
+ int id_;
+ multimap<recursive_multimap, recursive_multimap> multimap_;
+ friend bool operator< (const recursive_multimap &a, const recursive_multimap &b)
+ { return a.id_ < b.id_; }
+};
+
+template<class C>
+void test_move()
+{
+ //Now test move semantics
+ C original;
+ C move_ctor(boost::move(original));
+ C move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+}
+
+int main ()
+{
+ //Recursive container instantiation
+ {
+ set<recursive_set> set_;
+ multiset<recursive_multiset> multiset_;
+ map<recursive_map, recursive_map> map_;
+ multimap<recursive_multimap, recursive_multimap> multimap_;
+ }
+ //Now test move semantics
+ {
+ test_move<set<recursive_set> >();
+ test_move<multiset<recursive_multiset> >();
+ test_move<map<recursive_map, recursive_map> >();
+ test_move<multimap<recursive_multimap, recursive_multimap> >();
+ }
+
+ //using namespace boost::container::detail;
+
+ if(0 != test::set_test<MyBoostSet
+ ,MyStdSet
+ ,MyBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if(0 != test::set_test_copyable<MyBoostSet
+ ,MyStdSet
+ ,MyBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if(0 != test::set_test<MyMovableBoostSet
+ ,MyStdSet
+ ,MyMovableBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if(0 != test::set_test<MyMoveCopyBoostSet
+ ,MyStdSet
+ ,MyMoveCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if(0 != test::set_test_copyable<MyMoveCopyBoostSet
+ ,MyStdSet
+ ,MyMoveCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if(0 != test::set_test<MyCopyBoostSet
+ ,MyStdSet
+ ,MyCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if(0 != test::set_test_copyable<MyCopyBoostSet
+ ,MyStdSet
+ ,MyCopyBoostMultiSet
+ ,MyStdMultiSet>()){
+ return 1;
+ }
+
+ if (0 != test::map_test<MyBoostMap
+ ,MyStdMap
+ ,MyBoostMultiMap
+ ,MyStdMultiMap>()){
+ return 1;
+ }
+
+ if(0 != test::map_test_copyable<MyBoostMap
+ ,MyStdMap
+ ,MyBoostMultiMap
+ ,MyStdMultiMap>()){
+ return 1;
+ }
+
+// if (0 != test::map_test<my_managed_shared_memory
+// ,MyMovableBoostMap
+// ,MyStdMap
+// ,MyMovableBoostMultiMap
+// ,MyStdMultiMap>()){
+// return 1;
+// }
+
+ if (0 != test::map_test<MyMoveCopyBoostMap
+ ,MyStdMap
+ ,MyMoveCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ return 1;
+ }
+
+ if (0 != test::map_test_copyable<MyMoveCopyBoostMap
+ ,MyStdMap
+ ,MyMoveCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ return 1;
+ }
+
+ if (0 != test::map_test<MyCopyBoostMap
+ ,MyStdMap
+ ,MyCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ return 1;
+ }
+
+ if (0 != test::map_test_copyable<MyCopyBoostMap
+ ,MyStdMap
+ ,MyCopyBoostMultiMap
+ ,MyStdMultiMap>()){
+ return 1;
+ }
+
+ const test::EmplaceOptions SetOptions = (test::EmplaceOptions)(test::EMPLACE_HINT | test::EMPLACE_ASSOC);
+ if(!boost::container::test::test_emplace<set<test::EmplaceInt>, SetOptions>())
+ return 1;
+ if(!boost::container::test::test_emplace<multiset<test::EmplaceInt>, SetOptions>())
+ return 1;
+ const test::EmplaceOptions MapOptions = (test::EmplaceOptions)(test::EMPLACE_HINT_PAIR | test::EMPLACE_ASSOC_PAIR);
+ if(!boost::container::test::test_emplace<map<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+ return 1;
+ if(!boost::container::test::test_emplace<multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+ return 1;
+
+ return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/util.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/util.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,113 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation. William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+
+#ifndef BOOST_CONTAINER_TEST_UTIL_HEADER
+#define BOOST_CONTAINER_TEST_UTIL_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/sync/container_mutex.hpp>
+#include <boost/container/sync/container_condition.hpp>
+#include <boost/container/sync/scoped_lock.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <algorithm>
+#include <iostream>
+
+#ifndef DEFAULT_EXECUTION_MONITOR_TYPE
+# define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_condition
+#endif
+
+namespace boost {
+namespace container {
+namespace test {
+
+inline void sleep(const boost::posix_time::ptime &xt)
+{
+ boost::container::container_mutex mx;
+ boost::container::scoped_lock<boost::container::container_mutex>
+ lock(mx);
+ boost::container::container_condition cond;
+ cond.timed_wait(lock, xt);
+}
+
+inline boost::posix_time::ptime delay(int secs, int msecs=0, int nsecs = 0)
+{
+ (void)msecs;
+ using namespace boost::posix_time;
+ int count = static_cast<int>(double(nsecs)*
+ (double(time_duration::ticks_per_second())/double(1000000000.0)));
+ count += static_cast<int>(double(msecs)*
+ (double(time_duration::ticks_per_second())/double(1000.0)));
+ boost::posix_time::ptime cur = microsec_clock::universal_time();
+ return cur += boost::posix_time::time_duration(0, 0, secs, count);
+}
+
+inline bool in_range(const boost::posix_time::ptime& xt, int secs=1)
+{
+ boost::posix_time::ptime min = delay(-secs);
+ boost::posix_time::ptime max = delay(0);
+ return (xt > min) && (max > xt);
+}
+
+boost::xtime xsecs(int secs)
+{
+ boost::xtime ret;
+ boost::xtime_get(&ret, boost::TIME_UTC);
+ ret.sec += secs;
+ return ret;
+}
+
+template <typename P>
+class thread_adapter
+{
+ public:
+ thread_adapter(void (*func)(void*, P &), void* param1, P &param2)
+ : _func(func), _param1(param1) ,_param2(param2){ }
+ void operator()() const { _func(_param1, _param2); }
+
+ private:
+ void (*_func)(void*, P &);
+ void* _param1;
+ P& _param2;
+};
+
+template <typename P>
+struct data
+{
+ data(int id, int secs=0)
+ : m_id(id), m_value(-1), m_secs(secs)
+ {}
+ int m_id;
+ int m_value;
+ int m_secs;
+};
+
+static int shared_val = 0;
+static const int BaseSeconds = 1;
+
+} //namespace test {
+} //namespace container {
+} //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_UTIL_HEADER

Added: trunk/libs/container/test/vector_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/vector_test.cpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,127 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <functional>
+
+#include <boost/container/vector.hpp>
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "dummy_test_allocator.hpp"
+#include "vector_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::vector<test::movable_and_copyable_int,
+ test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+int test_expand_bwd()
+{
+ //Now test all back insertion possibilities
+
+ //First raw ints
+ typedef test::expand_bwd_test_allocator<int>
+ int_allocator_type;
+ typedef vector<int, int_allocator_type>
+ int_vector;
+
+ if(!test::test_all_expand_bwd<int_vector>())
+ return 1;
+
+ //Now user defined wrapped int
+ typedef test::expand_bwd_test_allocator<test::int_holder>
+ int_holder_allocator_type;
+ typedef vector<test::int_holder, int_holder_allocator_type>
+ int_holder_vector;
+
+ if(!test::test_all_expand_bwd<int_holder_vector>())
+ return 1;
+
+ //Now user defined bigger wrapped int
+ typedef test::expand_bwd_test_allocator<test::triple_int_holder>
+ triple_int_holder_allocator_type;
+
+ typedef vector<test::triple_int_holder, triple_int_holder_allocator_type>
+ triple_int_holder_vector;
+
+ if(!test::test_all_expand_bwd<triple_int_holder_vector>())
+ return 1;
+
+ return 0;
+}
+
+class recursive_vector
+{
+ public:
+ int id_;
+ vector<recursive_vector> vector_;
+};
+
+void recursive_vector_test()//Test for recursive types
+{
+ vector<recursive_vector> recursive_vector_vector;
+}
+
+enum Test
+{
+ zero, one, two, three, four, five, six
+};
+
+
+int main()
+{
+ recursive_vector_test();
+ {
+ //Now test move semantics
+ vector<recursive_vector> original;
+ vector<recursive_vector> move_ctor(boost::move(original));
+ vector<recursive_vector> move_assign;
+ move_assign = boost::move(move_ctor);
+ move_assign.swap(original);
+ }
+ typedef vector<int> MyVector;
+ typedef vector<test::movable_int> MyMoveVector;
+ typedef vector<test::movable_and_copyable_int> MyCopyMoveVector;
+ typedef vector<test::copyable_int> MyCopyVector;
+ typedef vector<Test> MyEnumVector;
+
+
+ if(test::vector_test<MyVector>())
+ return 1;
+ if(test::vector_test<MyMoveVector>())
+ return 1;
+ if(test::vector_test<MyCopyMoveVector>())
+ return 1;
+ if(test::vector_test<MyCopyVector>())
+ return 1;
+ if(test_expand_bwd())
+ return 1;
+
+ MyEnumVector v;
+ Test t;
+ v.push_back(t);
+ v.push_back(::boost::move(t));
+ v.push_back(Test());
+
+ const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+ if(!boost::container::test::test_emplace
+ < vector<test::EmplaceInt>, Options>())
+ return 1;
+
+ return 0;
+}
+#include <boost/container/detail/config_end.hpp>

Added: trunk/libs/container/test/vector_test.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/container/test/vector_test.hpp 2011-08-26 14:26:44 EDT (Fri, 26 Aug 2011)
@@ -0,0 +1,253 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <functional>
+#include <list>
+
+#include <boost/move/move.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include <string>
+#include <vector>
+#include "emplace_test.hpp"
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class V1, class V2>
+bool vector_copyable_only(V1 *, V2 *, boost::container::containers_detail::false_type)
+{
+ return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool vector_copyable_only(V1 *boostvector, V2 *stdvector, boost::container::containers_detail::true_type)
+{
+ typedef typename V1::value_type IntType;
+ std::size_t size = boostvector->size();
+ boostvector->insert(boostvector->end(), 50, IntType(1));
+ stdvector->insert(stdvector->end(), 50, 1);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+ {
+ IntType move_me(1);
+ boostvector->insert(boostvector->begin()+size/2, 50, boost::move(move_me));
+ stdvector->insert(stdvector->begin()+size/2, 50, 1);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+ }
+ {
+ IntType move_me(2);
+ boostvector->assign(boostvector->size()/2, boost::move(move_me));
+ stdvector->assign(stdvector->size()/2, 2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+ }
+ {
+ IntType move_me(3);
+ boostvector->assign(boostvector->size()*3-1, boost::move(move_me));
+ stdvector->assign(stdvector->size()*3-1, 3);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+ }
+
+ {
+ IntType copy_me(3);
+ const IntType ccopy_me(3);
+ boostvector->push_back(copy_me);
+ stdvector->push_back(int(3));
+ boostvector->push_back(ccopy_me);
+ stdvector->push_back(int(3));
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+ }
+
+ return true;
+}
+
+template<class MyBoostVector>
+int vector_test()
+{
+ typedef std::vector<int> MyStdVector;
+ typedef typename MyBoostVector::value_type IntType;
+ const int max = 100;
+
+ {
+ try{
+ MyBoostVector *boostvector = new MyBoostVector;
+ MyStdVector *stdvector = new MyStdVector;
+ boostvector->resize(100);
+ stdvector->resize(100);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->resize(200);
+ stdvector->resize(200);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->resize(0);
+ stdvector->resize(0);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0; i < max; ++i){
+ IntType new_int(i);
+ boostvector->insert(boostvector->end(), boost::move(new_int));
+ stdvector->insert(stdvector->end(), i);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ typename MyBoostVector::iterator boostit(boostvector->begin());
+ typename MyStdVector::iterator stdit(stdvector->begin());
+ typename MyBoostVector::const_iterator cboostit = boostit;
+ ++boostit; ++stdit;
+ boostvector->erase(boostit);
+ stdvector->erase(stdit);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->erase(boostvector->begin());
+ stdvector->erase(stdvector->begin());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ {
+ //Initialize values
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType new_int(-1);
+ BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
+ aux_vect[i] = boost::move(new_int);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+
+ boostvector->insert(boostvector->end()
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(aux_vect + 50));
+ stdvector->insert(stdvector->end(), aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0, j = static_cast<int>(boostvector->size()); i < j; ++i){
+ boostvector->erase(boostvector->begin());
+ stdvector->erase(stdvector->begin());
+ }
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+ {
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType new_int(-1);
+ aux_vect[i] = boost::move(new_int);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ boostvector->insert(boostvector->begin()
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(aux_vect + 50));
+ stdvector->insert(stdvector->begin(), aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+/*
+ boostvector->reserve(boostvector->size()*2);
+ stdvector->reserve(stdvector->size()*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+*/
+ boostvector->shrink_to_fit();
+ MyStdVector(*stdvector).swap(*stdvector);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->shrink_to_fit();
+ MyStdVector(*stdvector).swap(*stdvector);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ IntType push_back_this(1);
+ boostvector->push_back(boost::move(push_back_this));
+ stdvector->push_back(int(1));
+ boostvector->push_back(IntType(1));
+ stdvector->push_back(int(1));
+
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ if(!vector_copyable_only(boostvector, stdvector
+ ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+ return 1;
+ }
+
+ boostvector->erase(boostvector->begin());
+ stdvector->erase(stdvector->begin());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0; i < max; ++i){
+ IntType insert_this(i);
+ boostvector->insert(boostvector->begin(), boost::move(insert_this));
+ stdvector->insert(stdvector->begin(), i);
+ boostvector->insert(boostvector->begin(), IntType(i));
+ stdvector->insert(stdvector->begin(), int(i));
+ }
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ //Test insertion from list
+ {
+ std::list<int> l(50, int(1));
+ boostvector->insert(boostvector->begin(), l.begin(), l.end());
+ stdvector->insert(stdvector->begin(), l.begin(), l.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ boostvector->assign(l.begin(), l.end());
+ stdvector->assign(l.begin(), l.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+/*
+ std::size_t cap = boostvector->capacity();
+ boostvector->reserve(cap*2);
+ stdvector->reserve(cap*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ boostvector->resize(0);
+ stdvector->resize(0);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->resize(cap*2);
+ stdvector->resize(cap*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->clear();
+ stdvector->clear();
+ boostvector->shrink_to_fit();
+ MyStdVector(*stdvector).swap(*stdvector);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector->resize(cap*2);
+ stdvector->resize(cap*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+*/
+
+ delete stdvector;
+ delete boostvector;
+ }
+ catch(std::exception &ex){
+ std::cout << ex.what() << std::endl;
+ return 1;
+ }
+ }
+ std::cout << std::endl << "Test OK!" << std::endl;
+ return 0;
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk