[Boost-commit] svn:boost r78516 - in trunk/libs/intrusive: doc example perf proj/vc7ide test

Subject: [Boost-commit] svn:boost r78516 - in trunk/libs/intrusive: doc example perf proj/vc7ide test
From: igaztanaga_at_[hidden]
Date: 2012-05-20 05:54:53

Author: igaztanaga
Date: 2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
New Revision: 78516
URL: http://svn.boost.org/trac/boost/changeset/78516

Log:
Trailing whitespaces
Text files modified: 
   trunk/libs/intrusive/doc/Jamfile.v2                             |    20 +-                                      
   trunk/libs/intrusive/doc/index.idx                              |     2                                         
   trunk/libs/intrusive/doc/intrusive.qbk                          |   230 ++++++++++++++++++++--------------------
   trunk/libs/intrusive/example/Jamfile.v2                         |    12 +-                                      
   trunk/libs/intrusive/example/doc_advanced_value_traits.cpp      |    12 +-                                      
   trunk/libs/intrusive/example/doc_advanced_value_traits2.cpp     |    10                                         
   trunk/libs/intrusive/example/doc_assoc_optimized_code.cpp       |     4                                         
   trunk/libs/intrusive/example/doc_avl_set.cpp                    |     6                                         
   trunk/libs/intrusive/example/doc_avltree_algorithms.cpp         |    16 +-                                      
   trunk/libs/intrusive/example/doc_entity.cpp                     |     4                                         
   trunk/libs/intrusive/example/doc_external_value_traits.cpp      |     6                                         
   trunk/libs/intrusive/example/doc_list.cpp                       |     2                                         
   trunk/libs/intrusive/example/doc_list_algorithms.cpp            |     8                                         
   trunk/libs/intrusive/example/doc_offset_ptr.cpp                 |     4                                         
   trunk/libs/intrusive/example/doc_rbtree_algorithms.cpp          |    16 +-                                      
   trunk/libs/intrusive/example/doc_set.cpp                        |     6                                         
   trunk/libs/intrusive/example/doc_sg_set.cpp                     |     2                                         
   trunk/libs/intrusive/example/doc_slist_algorithms.cpp           |     4                                         
   trunk/libs/intrusive/example/doc_splay_algorithms.cpp           |    14 +-                                      
   trunk/libs/intrusive/example/doc_splay_set.cpp                  |     2                                         
   trunk/libs/intrusive/example/doc_splaytree_algorithms.cpp       |    14 +-                                      
   trunk/libs/intrusive/example/doc_stateful_value_traits.cpp      |     4                                         
   trunk/libs/intrusive/example/doc_treap_algorithms.cpp           |    14 +-                                      
   trunk/libs/intrusive/example/doc_treap_set.cpp                  |     2                                         
   trunk/libs/intrusive/example/doc_value_traits.cpp               |    12 +-                                      
   trunk/libs/intrusive/example/doc_window.cpp                     |     4                                         
   trunk/libs/intrusive/perf/Jamfile.v2                            |    12 +-                                      
   trunk/libs/intrusive/proj/vc7ide/to-do.txt                      |     2                                         
   trunk/libs/intrusive/test/Jamfile.v2                            |    10                                         
   trunk/libs/intrusive/test/avl_multiset_test.cpp                 |     4                                         
   trunk/libs/intrusive/test/avl_set_test.cpp                      |     4                                         
   trunk/libs/intrusive/test/common_functors.hpp                   |     2                                         
   trunk/libs/intrusive/test/external_value_traits_test.cpp        |     6                                         
   trunk/libs/intrusive/test/generic_assoc_test.hpp                |     6                                         
   trunk/libs/intrusive/test/generic_multiset_test.hpp             |    18 +-                                      
   trunk/libs/intrusive/test/generic_set_test.hpp                  |    18 +-                                      
   trunk/libs/intrusive/test/has_member_function_callable_with.cpp |    18 +-                                      
   trunk/libs/intrusive/test/itestvalue.hpp                        |     4                                         
   trunk/libs/intrusive/test/list_test.cpp                         |    16 +-                                      
   trunk/libs/intrusive/test/multiset_test.cpp                     |     4                                         
   trunk/libs/intrusive/test/recursive_test.cpp                    |     2                                         
   trunk/libs/intrusive/test/set_test.cpp                          |     4                                         
   trunk/libs/intrusive/test/sg_multiset_test.cpp                  |     4                                         
   trunk/libs/intrusive/test/sg_set_test.cpp                       |     6                                         
   trunk/libs/intrusive/test/slist_test.cpp                        |    24 ++--                                    
   trunk/libs/intrusive/test/smart_ptr.hpp                         |    98 ++++++++--------                        
   trunk/libs/intrusive/test/splay_multiset_test.cpp               |     6                                         
   trunk/libs/intrusive/test/splay_set_test.cpp                    |     2                                         
   trunk/libs/intrusive/test/stateful_value_traits_test.cpp        |     6                                         
   trunk/libs/intrusive/test/test_container.hpp                    |     2                                         
   trunk/libs/intrusive/test/treap_multiset_test.cpp               |     4                                         
   trunk/libs/intrusive/test/treap_set_test.cpp                    |     6                                         
   trunk/libs/intrusive/test/unordered_multiset_test.cpp           |    26 ++--                                    
   trunk/libs/intrusive/test/unordered_set_test.cpp                |    24 ++--                                    
   trunk/libs/intrusive/test/virtual_base_test.cpp                 |     2                                         
   55 files changed, 385 insertions(+), 385 deletions(-)

Modified: trunk/libs/intrusive/doc/Jamfile.v2
==============================================================================
--- trunk/libs/intrusive/doc/Jamfile.v2	(original)
+++ trunk/libs/intrusive/doc/Jamfile.v2	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -1,6 +1,6 @@
 #  Boost.Intrusive library documentation Jamfile
 #
-#  Copyright Ion Gaztanaga 2006. 
+#  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)
@@ -46,9 +46,9 @@
    ;
 
 xml intrusive : intrusive.qbk
-              : 
+              :
                  <include>../../../tools/auto_index/include
-              ;   
+              ;  
 
 boostbook standalone
    :
@@ -61,26 +61,26 @@
         <dependency>autodoc
 
         # Build requirements go here:
-        
+       
         # <auto-index>on (or off) one turns on (or off) indexing:
         <auto-index>on
-        
+       
         # Turns on (or off) auto-index-verbose for diagnostic info.
         # This is highly recommended until you have got all the many details correct!
-        <auto-index-verbose>on 
-        
+        <auto-index-verbose>on
+       
         # Choose the indexing method (separately for html and PDF) - see manual.
         # Choose indexing method for PDFs:
         <format>pdf:<auto-index-internal>off
-        
+       
         # Choose indexing method for html:
         <format>html:<auto-index-internal>on
-        
+       
         # Set the name of the script file to use (index.idx is popular):
         <auto-index-script>index.idx
         # Commands in the script file should all use RELATIVE PATHS
         # otherwise the script will not be portable to other machines.
-        # Relative paths are normally taken as relative to the location 
+        # Relative paths are normally taken as relative to the location
         # of the script file, but we can add a prefix to all
         # those relative paths using the <auto-index-prefix> feature.
         # The path specified by <auto-index-prefix> may be either relative or

Modified: trunk/libs/intrusive/doc/index.idx
==============================================================================
--- trunk/libs/intrusive/doc/index.idx	(original)
+++ trunk/libs/intrusive/doc/index.idx	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -1 +1 @@
-!scan-path "boost/intrusive" ".*.hpp" false 
+!scan-path "boost/intrusive" ".*.hpp" false

Modified: trunk/libs/intrusive/doc/intrusive.qbk
==============================================================================
--- trunk/libs/intrusive/doc/intrusive.qbk	(original)
+++ trunk/libs/intrusive/doc/intrusive.qbk	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -26,7 +26,7 @@
 [*Boost.Intrusive] is a library presenting some intrusive containers to
 the world of C++. Intrusive containers are special containers
 that offer [link intrusive.performance better performance]
-and exception safety guarantees than non-intrusive containers (like STL containers). 
+and exception safety guarantees than non-intrusive containers (like STL containers).
 
 The performance benefits of intrusive containers makes them ideal as a building
 block to efficiently construct complex containers like multi-index containers or
@@ -88,7 +88,7 @@
    {
       list_node *next;
       list_node *previous;
-      MyClass    value; 
+      MyClass    value;
    };
 
 
@@ -127,11 +127,11 @@
 
 [section:properties_of_intrusive Properties of Boost.Intrusive containers]
 
-Semantically, a [*Boost.Intrusive] container is similar to a STL container 
+Semantically, a [*Boost.Intrusive] container is similar to a STL container
 holding pointers to objects. That is, if you have an intrusive list holding
 objects of type `T`, then `std::list<T*>` would allow you to do quite the
 same operations (maintaining and navigating a set of objects of type T and
-types derived from it). 
+types derived from it).
 
 A non-intrusive container has some limitations:
 
@@ -151,7 +151,7 @@
 *  It's not possible to store a derived object in a STL-container while
    retaining its original type.
 
-Intrusive containers have some important advantages: 
+Intrusive containers have some important advantages:
 
 *  Operating with intrusive containers doesn't invoke any memory management at all.
    The time and size overhead associated with dynamic memory can be minimized.
@@ -160,7 +160,7 @@
    equivalent container of pointers: iteration is faster.
 
 *  Intrusive containers offer better exception guarantees than non-intrusive containers.
-   In some situations intrusive containers offer a no-throw guarantee that can't be 
+   In some situations intrusive containers offer a no-throw guarantee that can't be
    achieved with non-intrusive containers.
 
 *  The computation of an iterator to an element from a pointer or reference to that element
@@ -174,16 +174,16 @@
 
 Intrusive containers have also downsides:
 
-*  Each type stored in an intrusive container needs additional memory holding the 
+*  Each type stored in an intrusive container needs additional memory holding the
    maintenance information needed by the container. Hence, whenever a certain type will
    be stored in an intrusive container [*you have to change the definition of that type]
-   appropriately. Although this task is easy with [*Boost.Intrusive], touching the 
+   appropriately. Although this task is easy with [*Boost.Intrusive], touching the
    definition of a type is sometimes a crucial issue.
 
 *  In intrusive containers you don't store a copy of an object, [*but rather the original object
    is linked with other objects in the container]. Objects don't need copy-constructors or assignment
-   operators to be stored in intrusive containers. But you have to take care of possible side effects, 
-   whenever you change the contents of an object (this is especially important for 
+   operators to be stored in intrusive containers. But you have to take care of possible side effects,
+   whenever you change the contents of an object (this is especially important for
    associative containers).
 
 *  The user [*has to manage the lifetime of inserted objects] independently from the
@@ -230,9 +230,9 @@
 
 [section:usage How to use Boost.Intrusive]
 
-If you plan to insert a class in an intrusive container, you have to make some decisions 
-influencing the class definition itself. Each class that will be used in an intrusive 
-container needs some appropriate data members storing the information needed by the 
+If you plan to insert a class in an intrusive container, you have to make some decisions
+influencing the class definition itself. Each class that will be used in an intrusive
+container needs some appropriate data members storing the information needed by the
 container. We will take a simple intrusive container, the intrusive list
 ([classref boost::intrusive::list boost::intrusive::list]), for the following
 examples, but all [*Boost.Intrusive] containers are very similar. To compile
@@ -246,14 +246,14 @@
 Every class to be inserted in an intrusive container, needs to contain a hook that
 will offer the necessary data and resources to be insertable in the container.
 With [*Boost.Intrusive] you just choose the hook to be a public base class or
-a public member of the class to be inserted. [*Boost.Intrusive] also offers 
+a public member of the class to be inserted. [*Boost.Intrusive] also offers
 more flexible hooks for advanced users, as explained in the chapter
 [link intrusive.function_hooks Using function hooks], but usually base or member
 hooks are good enough for most users.
 
 [section:usage_base_hook Using base hooks]
 
-For [classref boost::intrusive::list list], you can publicly derive from 
+For [classref boost::intrusive::list list], you can publicly derive from
 [classref boost::intrusive::list_base_hook list_base_hook].
 
 [c++]
@@ -262,7 +262,7 @@
    class list_base_hook;
 
 The class can take several options. [*Boost.Intrusive] classes receive arguments in the
-form `option_name<option_value>`. You can specify the following options:   
+form `option_name<option_value>`. You can specify the following options:  
 
 *  [*`tag<class Tag>`]: this argument serves as a tag, so you can derive from more than one
    [classref boost::intrusive::list_base_hook list_base_hook] and hence put an object in
@@ -307,11 +307,11 @@
 `list` receives the type to be inserted in the container (`T`) as the first parameter
 and optionally, the user can specify options. We have 3 option types:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: All these options specify the relationship
    between the type `T` to be inserted in the list and the hook (since we can
    have several hooks in the same `T` type). `member_hook` will be explained
-   a bit later and `value_traits` will be explained in the 
+   a bit later and `value_traits` will be explained in the
    [link intrusive.value_traits Containers with custom ValueTraits] section.
    [*If no option is specified, the container will be configured to use the base
    hook with the default tag].
@@ -354,7 +354,7 @@
    #include <boost/intrusive/list.hpp>
 
    using namespace boost::intrusive;
-   
+  
    struct my_tag;
 
    typedef list_base_hook< tag<my_tag> > BaseHook;
@@ -397,10 +397,10 @@
 
    #include <boost/intrusive/list.hpp>
 
-   class Foo 
+   class Foo
    {
       public:
-      list_member_hook<> hook_;  
+      list_member_hook<> hook_; 
       //...
    };
 
@@ -431,7 +431,7 @@
 
 [section:usage_both_hooks Using both hooks]
 
-You can insert the same object in several intrusive containers at the same time, 
+You can insert the same object in several intrusive containers at the same time,
 using one hook per container. This is a full example using base and member hooks:
 
 [import ../example/doc_how_to_use.cpp]
@@ -442,13 +442,13 @@
 [section:usage_lifetime Object lifetime]
 
 Even if the interface of [classref boost::intrusive::list list] is similar to
-`std::list`, its usage is a bit different: You always have to keep in mind that 
-you directly store objects in intrusive containers, not copies. The lifetime of a 
+`std::list`, its usage is a bit different: You always have to keep in mind that
+you directly store objects in intrusive containers, not copies. The lifetime of a
 stored object is not bound to or managed by the container:
 
 *  When the container gets destroyed before the object, the object is not destroyed,
    so you have to be careful to avoid resource leaks.
-   
+  
 *  When the object is destroyed before the container, your program is likely to crash,
    because the container contains a pointer to an non-existing object.
 
@@ -470,7 +470,7 @@
 *  it's important to achieve a well-known worst-time system response.
 *  localization of data (e.g. for cache hit optimization) leads to measurable effects.
 
-The last point is important if you have a lot of containers over a set of elements. E.g. if 
+The last point is important if you have a lot of containers over a set of elements. E.g. if
 you have a vector of objects (say, `std::vector<Object>`), and you also have a list
 storing a subset of those objects (`std::list<Object*>`), then operating on an Object
 from the list iterator (`std::list<Object*>::iterator`) requires two steps:
@@ -484,16 +484,16 @@
 Hence depending on your system you might get a lot of cache misses. The same doesn't hold
 for an intrusive list. Indeed, dereferencing an iterator from an intrusive list is performed in
 the same two steps as described above. But the list node is already embedded in the Object, so
-the memory is directly tracked from the iterator to the Object. 
+the memory is directly tracked from the iterator to the Object.
 
 It's also possible to use intrusive containers when the objects to be stored can
 have different or unknown size. This allows storing base and derived objects
-in the same container, as shown in the following example: 
+in the same container, as shown in the following example:
 
 [import ../example/doc_window.cpp]
 [doc_window_code]
 
-Due to certain properties of intrusive containers 
+Due to certain properties of intrusive containers
 they are often more difficult to use than their STL-counterparts. That's why you
 should avoid them in public interfaces of libraries. Classes to be stored in intrusive
 containers must change their implementation to store the hook and this is not always
@@ -507,7 +507,7 @@
 chapters:
 
 [variablelist Brief Concepts Summary
-[[Node Algorithms][A class containing typedefs and static functions that define 
+[[Node Algorithms][A class containing typedefs and static functions that define
    basic operations that can be applied to a group of nodes. It's independent
    from the node definition and configured using a NodeTraits template
    parameter that describes the node.]]
@@ -543,7 +543,7 @@
    Many operations have logarithmic time complexity.
 
 *  [*splay_set/splay_multiset/splaytree]: `std::set/std::multiset` like intrusive associative
-   containers based on splay trees. Splay trees have no constant operations, but they  
+   containers based on splay trees. Splay trees have no constant operations, but they 
    have some interesting caching properties.
    The size overhead is moderate for user classes (usually the size of three pointers).
    Many operations have logarithmic time complexity.
@@ -595,7 +595,7 @@
    automatically and the user can safely unlink the object from the container without
    referring to the container.
 
-*  [*Non-raw pointers]: If the user wants to use smart pointers instead of raw pointers, 
+*  [*Non-raw pointers]: If the user wants to use smart pointers instead of raw pointers,
    [*Boost.Intrusive] hooks can
    be configured to use any type of pointer. This configuration information is also
    transmitted to the containers, so all the internal pointers used by intrusive containers
@@ -636,7 +636,7 @@
 
 With these features, without any external reference the user can know if the object
 has been inserted in a container by calling the `is_linked()` member function.
-If the object is not actually inserted 
+If the object is not actually inserted
 in a container, the hook is in the default state, and if it is inserted in a container, the
 hook is not in the default state.
 
@@ -689,11 +689,11 @@
 These hooks have exactly the same size overhead as their analog non auto-unlinking
 hooks, but they have a restriction: they can only be used with
 [link intrusive.presenting_containers non-constant time containers].
-There is a reason for this: 
+There is a reason for this:
 
 * Auto-unlink hooks don't store any reference to the container where they are inserted.
 * Only containers with non constant-time `size()` allow removing an object from the container
-  without referring to the container. 
+  without referring to the container.
 
 This auto-unlink feature is useful in certain applications
 but it must be used [*very carefully]:
@@ -734,7 +734,7 @@
 auto-unlink hook's value_traits, you will get a static assertion:
 
 [c++]
-   
+  
    #include <boost/intrusive/list.hpp>
 
    using boost::intrusive;
@@ -776,7 +776,7 @@
 
 [classref boost::intrusive::slist slist] is the simplest intrusive container of
 [*Boost.Intrusive]: a singly linked list. The memory overhead
-it imposes is 1 pointer per node. The size of an empty, non constant-time size 
+it imposes is 1 pointer per node. The size of an empty, non constant-time size
 [classref boost::intrusive::slist slist] is the size of 1 pointer. This
 lightweight memory overhead comes with drawbacks, though: many operations have
 linear time complexity, even some that usually are constant time, like
@@ -810,7 +810,7 @@
    class slist_member_hook;
 
 *  [classref boost::intrusive::slist_member_hook slist_member_hook]:
-   the user class contains a public 
+   the user class contains a public
    [classref boost::intrusive::slist_member_hook slist_member_hook] to make
    it [classref boost::intrusive::slist slist]-compatible.
 
@@ -842,7 +842,7 @@
 [classref boost::intrusive::slist slist] receives the options explained in
 the section [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -911,8 +911,8 @@
    template <class ...Options>
    class list_member_hook;
 
-*  [classref boost::intrusive::list_member_hook list_member_hook]: 
-   the user class contains a public 
+*  [classref boost::intrusive::list_member_hook list_member_hook]:
+   the user class contains a public
    [classref boost::intrusive::list_member_hook list_member_hook] to make
    it [classref boost::intrusive::list list]-compatible.
 
@@ -944,7 +944,7 @@
 [classref boost::intrusive::list list] receives the same options explained in
 the section [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -972,7 +972,7 @@
 
 [*Boost.Intrusive] also offers associative containers that can be very useful
 when creating more complex associative containers, like containers maintaining
-one or more indices with different sorting semantics. Boost.Intrusive associative 
+one or more indices with different sorting semantics. Boost.Intrusive associative
 containers, like most STL associative container implementations are based on
 red-black trees.
 
@@ -991,7 +991,7 @@
 [classref boost::intrusive::multiset multiset] are the
 intrusive equivalents of standard `std::set` and `std::multiset` containers.
 
-[classref boost::intrusive::rbtree rbtree] is a superset of 
+[classref boost::intrusive::rbtree rbtree] is a superset of
 [classref boost::intrusive::set set] and
 [classref boost::intrusive::multiset multiset] containers that offers
 functions to insert unique and multiple keys.
@@ -1068,7 +1068,7 @@
 These containers receive the same options explained in the section
 [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -1113,11 +1113,11 @@
 implement any memory management at all. However, the user can request an explicit
 rehashing passing a new bucket array.
 This also offers an additional guarantee over TR1 unordered associative containers:
-[*iterators are not invalidated when inserting an element] in the container. 
+[*iterators are not invalidated when inserting an element] in the container.
 
 As with TR1 unordered associative containers, rehashing invalidates iterators,
 changes ordering between elements and changes which buckets elements appear in,
-but does not invalidate pointers or references to elements. 
+but does not invalidate pointers or references to elements.
 
 Apart from expected hash and equality function objects, [*Boost.Intrusive] unordered
 associative containers' constructors take an argument specifying an auxiliary
@@ -1129,12 +1129,12 @@
 a bucket array per container. The size of an element of the bucket array
 is usually one pointer. To obtain a good performance hashed container,
 the bucket length is usually the same as the number of elements that the
-container contains, so a well-balanced hashed container (`bucket_count()` is 
+container contains, so a well-balanced hashed container (`bucket_count()` is
 equal to `size()` ) will have an equivalent overhead of two pointers per element.
 
 An empty, non constant-time size [classref boost::intrusive::unordered_set unordered_set] or
 [classref boost::intrusive::unordered_multiset unordered_multiset]
-has also the size of `bucket_count()` pointers. 
+has also the size of `bucket_count()` pointers.
 
 Insertions, erasures, and searches, have amortized constant-time complexity in
 hashed containers. However, some worst-case guarantees are linear. See
@@ -1253,7 +1253,7 @@
 receive the same options explained in the section
 [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -1306,7 +1306,7 @@
 
 *  [*`incremental<bool Enabled>`]: Activates incremental hashing (also known as Linear Hashing).
    This option implies `power_2_buckets<true>` and the container will require power of two buckets.
-   For more information on incremental hashing, see 
+   For more information on incremental hashing, see
    [@http://en.wikipedia.org/wiki/Linear_hashing `Linear hash` on Wikipedia]
    Default: `incremental<false>`
 
@@ -1339,7 +1339,7 @@
 
 The following bucket traits just stores a pointer to the bucket
 array but the size is a compile-time constant. Note the use of the auxiliary
-[classref boost::intrusive::unordered_bucket unordered_bucket] and 
+[classref boost::intrusive::unordered_bucket unordered_bucket] and
 [classref boost::intrusive::unordered_bucket_ptr unordered_bucket_ptr]
 utilities to obtain the type of the bucket and its pointer before defining
 the unordered container:
@@ -1454,7 +1454,7 @@
 These containers receive the same options explained in the section
 [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container.  (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -1510,12 +1510,12 @@
 
 [section:avl_set_multiset Intrusive avl tree based associative containers: avl_set, avl_multiset and avltree]
 
-Similar to red-black trees, AVL trees are balanced binary trees. 
+Similar to red-black trees, AVL trees are balanced binary trees.
 AVL trees are often compared with red-black trees because they support the same set of operations
-and because both take O(log n) time for basic operations. 
+and because both take O(log n) time for basic operations.
 AVL trees are more rigidly balanced than Red-Black trees, leading to slower insertion and
 removal but faster retrieval, so AVL trees perform better
-than red-black trees for lookup-intensive applications. 
+than red-black trees for lookup-intensive applications.
 
 [*Boost.Intrusive] offers 3 containers based on avl trees:
 [classref boost::intrusive::avl_set avl_set],
@@ -1603,7 +1603,7 @@
 These containers receive the same options explained in the section
 [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -1753,7 +1753,7 @@
 These containers receive the same options explained in the section
 [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -1767,7 +1767,7 @@
    in containers. The comparison functor must induce a strict weak ordering.
    Default: `compare< std::less<T> >`
 
-*  [*`floating_point<bool Enable>`]: 
+*  [*`floating_point<bool Enable>`]:
    When this option is deactivated, the scapegoat tree loses the ability to change
    the balance factor a at run-time, but the size of an empty container is reduced
    and no floating point operations are performed, normally increasing container
@@ -1796,7 +1796,7 @@
 The name ['treap] is a mixture of ['tree] and ['heap] indicating that Treaps exhibit the properties of both
 binary search trees and heaps. A treap is a binary search tree that orders the nodes
 by a key but also by a priority attribute. The nodes are ordered so that the keys form a binary search tree and
-the priorities obey the max heap order property. 
+the priorities obey the max heap order property.
 
 * If v is a left descendant of u, then key[v] < key[u];
 * If v is a right descendant of u, then key[v] > key[u];
@@ -1889,7 +1889,7 @@
 These containers receive the same options explained in the section
 [link intrusive.usage How to use Boost.Intrusive]:
 
-*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] / 
+*  [*`base_hook<class Hook>`] / [*`member_hook<class T, class Hook, Hook T::* PtrToMember>`] /
    [*`value_traits<class ValueTraits>`]: To specify the hook type or value traits used
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
@@ -1972,7 +1972,7 @@
 [section:advanced_lookups Advanced lookups]
 
 [*Boost.Intrusive] associative containers offer the same interface as STL associative
-containers. However, STL and TR1 ordered and unordered simple associative containers 
+containers. However, STL and TR1 ordered and unordered simple associative containers
 (`std::set`, `std::multiset`, `std::tr1::unordered_set` and `std::tr1::unordered_multiset`)
 have some inefficiencies caused by the interface: the user can only operate with `value_type`
 objects. When using these containers we must use `iterator find(const value_type &value)`
@@ -1988,7 +1988,7 @@
 `Expensive` has to construct a `std::string` using heap memory. Like
 `Expensive`, many times the only member taking part in ordering issues is just
 a small part of the class. For example, with `Expensive`, only the internal
-`std::string` is needed to compare the object. 
+`std::string` is needed to compare the object.
 
 In both containers, if we call `get_from_set/get_from_unordered_set` in a loop, we might get a performance penalty,
 because we are forced to create a whole `Expensive` object to be able to find an
@@ -2001,8 +2001,8 @@
 might require more information that the user might not have.
 
 To solve this, [classref boost::intrusive::set set]/[classref boost::intrusive::multiset multiset]
-offer alternative functions, which take any type comparable with the value and a 
-functor that should be compatible with the 
+offer alternative functions, which take any type comparable with the value and a
+functor that should be compatible with the
 ordering function of the associative container.
 [classref boost::intrusive::unordered_set unordered_set]/[classref boost::intrusive::unordered_multiset unordered_multiset]
 offers functions that take any key type and compatible hash and equality functions. Now, let's see the
@@ -2043,7 +2043,7 @@
 this function can be inefficient:
 
 [doc_assoc_optimized_code_normal_insert]
- 
+
 If the object is already present, we are constructing an `Expensive` that
 will be discarded, and this is a waste of resources. Instead of that, let's use
 `insert_check` and `insert_commit` functions:
@@ -2069,7 +2069,7 @@
 `insert_check` and `insert_commit`.
 
 With multiple ordered and unordered associative containers
-([classref boost::intrusive::multiset multiset] and 
+([classref boost::intrusive::multiset multiset] and
 [classref boost::intrusive::unordered_multiset unordered_multiset]) there  is
 no need for these advanced insertion functions, since insertions are always successful.
 
@@ -2100,7 +2100,7 @@
 [endsect]
 
 For more information about advanced lookup and insertion functions see
-associative containers' documentation (e.g. 
+associative containers' documentation (e.g.
 [classref boost::intrusive::set set],
 [classref boost::intrusive::multiset multiset],
 [classref boost::intrusive::unordered_set unordered_set] and
@@ -2132,10 +2132,10 @@
    void remove_and_dispose_if(Pred pred, Disposer disposer)
 
 With this function the user can efficiently remove and destroy elements if the disposer
-function destroys an object: `remove_and_dispose_if` 
+function destroys an object: `remove_and_dispose_if`
 will call the "disposer" function object for every removed element. [classref boost::intrusive::list list] offers
 more functions taking a disposer function object as argument, like `erase_and_dispose`, `clear_and_dispose`,
-`remove_and_dispose`, etc. 
+`remove_and_dispose`, etc.
 
 Note that the disposing function does not need to just destroy the object. It can
 implement any other operation like inserting the remove object in another container.
@@ -2169,7 +2169,7 @@
 
    template <class Cloner, class Disposer>
    void clone_from(const list &src, Cloner cloner, Disposer disposer);
-   
+  
 This function will make `*this` a clone of `src`. Let's explain the arguments:
 
 *   The first parameter is the list to be cloned.
@@ -2178,7 +2178,7 @@
    `pointer operator()(const value_type &)`.
 *   The second parameter is a function object that will dispose `value_type` objects. It's used first
    to empty the container before cloning and to dispose the elements if an exception is thrown.
-   
+  
 The cloning function works as follows:
 
 *   First it clears and disposes all the elements from *this using the disposer function object.
@@ -2229,7 +2229,7 @@
 is a bit more complicated, but [*Boost.Intrusive] offers a bit of help with the function
 [funcref boost::intrusive::get_parent_from_member get_parent_from_member],
 which allows easy conversions from the address of a data member to the address of
-the parent holding that member. Let's see a little example of 
+the parent holding that member. Let's see a little example of
 [classref boost::intrusive::function_hook function_hook]:
 
 [import ../example/doc_function_hooks.cpp]
@@ -2251,7 +2251,7 @@
 
 [c++]
 
-  //This leads to compilation error (Recursive is instantiated by 
+  //This leads to compilation error (Recursive is instantiated by
   //'list' to deduce hook properties (pointer type, tag, safe-mode...)
   class Recursive
   {  //...
@@ -2332,7 +2332,7 @@
 
 [*Boost.Intrusive] offers another useful feature that's not present in STL
 containers: it's possible to obtain an iterator to a value from the value itself.
-This feature is implemented in [*Boost.Intrusive] containers by a 
+This feature is implemented in [*Boost.Intrusive] containers by a
 function called `iterator_to`:
 
 [c++]
@@ -2352,7 +2352,7 @@
 ([classref boost::intrusive::list list],
 [classref boost::intrusive::slist slist],
 [classref boost::intrusive::set set],
-[classref boost::intrusive::multiset multiset]) we have an alternative 
+[classref boost::intrusive::multiset multiset]) we have an alternative
 static `s_iterator_to` function.
 
 For unordered associative containers
@@ -2367,7 +2367,7 @@
 if the programmer uses hooks provided by [*Boost.Intrusive], those functions
 will be available.
 
-Let's see a small function that shows the use of `iterator_to` and 
+Let's see a small function that shows the use of `iterator_to` and
 `local_iterator_to`:
 
 [import ../example/doc_iterator_from_value.cpp]
@@ -2452,7 +2452,7 @@
       }
 
       // number of elements in the group of nodes containing "this_node"
-      static std::size_t count(const_node_ptr this_node) 
+      static std::size_t count(const_node_ptr this_node)
       {
          std::size_t result = 0;
          const_node_ptr p = this_node;
@@ -2469,7 +2469,7 @@
 
 *  [*Node Traits]: A class that encapsulates the basic information and
    operations on a node within a group of nodes:
-   the type of the node, a function to obtain the pointer to the next node, etc. 
+   the type of the node, a function to obtain the pointer to the next node, etc.
    [*Node Traits] specify the configuration information [*Node Algorithms]
    need. Each type of [*Node Algorithm] expects an interface that compatible
    [*Node Traits] classes must implement.
@@ -2484,18 +2484,18 @@
       struct node
       {
          node *next_;
-      };      
-     
+      };     
+    
       typedef node *       node_ptr;
       typedef const node * const_node_ptr;
 
       //A function to obtain a pointer to the next node
       static node_ptr get_next(const_node_ptr n)
-      {  return n->next_;  }  
+      {  return n->next_;  } 
 
       //A function to set the pointer to the next node
       static void set_next(node_ptr n, node_ptr next)
-      {  n->next_ = next;  }  
+      {  n->next_ = next;  } 
    };
 
 
@@ -2544,7 +2544,7 @@
    value types that use different hooks. An intrusive container is also more elaborate
    than a group of nodes: it can store the number of elements to achieve constant-time
    size information, it can offer debugging facilities, etc.
-   For example, an [classref boost::intrusive::slist slist] container 
+   For example, an [classref boost::intrusive::slist slist] container
    (intrusive singly linked list) should
    be able to hold `MyClass` objects that might have decided to store the hook
    as a base class or as a member. Internally, the container will use [*Node Algorithms]
@@ -2565,10 +2565,10 @@
       // ...
 
       //Insert the value as the first element of the list
-      void push_front (reference value) 
+      void push_front (reference value)
       {
          node_ptr to_insert(ValueTraits::to_node_ptr(value));
-         circular_list_algorithms::link_after(to_insert, get_root_node()); 
+         circular_list_algorithms::link_after(to_insert, get_root_node());
       }
 
       // More operations
@@ -2584,7 +2584,7 @@
    that will be inserted in a group of nodes. [*Node Algorithms] just work
    with nodes and don't know anything about user classes. On the other
    hand, an intrusive container needs to know how to obtain a node from a user class,
-   and also the inverse operation.   
+   and also the inverse operation.  
    So we can define [*ValueTraits] as the glue between user classes and nodes
    required by [*Node Algorithms].
    Let's see a possible implementation of a value traits class that glues MyClass
@@ -2606,7 +2606,7 @@
       { return static_cast<slist_base_hook &>(value).to_node_ptr(); }
 
       //Converts a generic node into user's value
-      static value_type *to_value_ptr(node_traits::node *n) 
+      static value_type *to_value_ptr(node_traits::node *n)
       { static_cast<value_type*>(slist_base_hook::to_hook_ptr(n)); }
 
       // More operations
@@ -2643,7 +2643,7 @@
 
 An empty list is formed by a node whose pointer to the next node points
 to itself. [classref boost::intrusive::circular_slist_algorithms circular_slist_algorithms]
-is configured with a NodeTraits class, which encapsulates 
+is configured with a NodeTraits class, which encapsulates
 the information about the node to be manipulated. NodeTraits must support the
 following interface:
 
@@ -2686,7 +2686,7 @@
 
 An empty list is formed by a node whose pointer to the next node points
 to itself. [classref boost::intrusive::circular_list_algorithms circular_list_algorithms]
-is configured with a NodeTraits class, which encapsulates 
+is configured with a NodeTraits class, which encapsulates
 the information about the node to be manipulated. NodeTraits must support the
 following interface:
 
@@ -2737,7 +2737,7 @@
 An empty tree is formed by a node whose pointer to the parent node is null,
 the left and right node pointers point to itself, and whose color is red.
 [classref boost::intrusive::rbtree_algorithms rbtree_algorithms]
-is configured with a NodeTraits class, which encapsulates 
+is configured with a NodeTraits class, which encapsulates
 the information about the node to be manipulated. NodeTraits must support the
 following interface:
 
@@ -2808,7 +2808,7 @@
 An empty tree is formed by a node whose pointer to the parent node is null,
 and whose left and right nodes pointers point to itself.
 [classref boost::intrusive::splaytree_algorithms splaytree_algorithms]
-is configured with a NodeTraits class, which encapsulates 
+is configured with a NodeTraits class, which encapsulates
 the information about the node to be manipulated. NodeTraits must support the
 following interface:
 
@@ -2862,7 +2862,7 @@
    struct avltree_algorithms;
 
 [classref boost::intrusive::avltree_algorithms avltree_algorithms]
-is configured with a NodeTraits class, which encapsulates 
+is configured with a NodeTraits class, which encapsulates
 the information about the node to be manipulated. NodeTraits must support the
 following interface:
 
@@ -2934,7 +2934,7 @@
    struct treap_algorithms;
 
 [classref boost::intrusive::treap_algorithms treap_algorithms]
-is configured with a NodeTraits class, which encapsulates 
+is configured with a NodeTraits class, which encapsulates
 the information about the node to be manipulated. NodeTraits must support the
 following interface:
 
@@ -2992,7 +2992,7 @@
 /   struct sgtree_algorithms;
 /
 /[classref boost::intrusive::sgtree_algorithms sgtree_algorithms]
-/is configured with a NodeTraits class, which encapsulates 
+/is configured with a NodeTraits class, which encapsulates
 /the information about the node to be manipulated. NodeTraits must support the
 /following interface:
 /
@@ -3111,23 +3111,23 @@
 *  [*['node_ptr]]: A typedef for `node_traits::node_ptr`.
 
 *  [*['const_node_ptr]]: A typedef for `node_traits::const_node_ptr`.
-   
+  
 *  [*['value_type]]: The type that the user wants to insert in the container. This type can be
    the same as `node_traits::node` but it can be different (for example, `node_traits::node`
    can be a member type of `value_type`). If `value_type` and `node_traits::node` are the
    same type, the `to_node_ptr` and `to_value_ptr` functions are trivial.
-   
+  
 *  [*['pointer]]: The type of a pointer to a `value_type`. It must be the same pointer type
    as `node_ptr`: If `node_ptr` is `node*`, `pointer` must be `value_type*`. If
    `node_ptr` is `smart_ptr<node_traits::node>`, `pointer` must be `smart_ptr<value_type>`.
    This can be generically achieved using `boost::intrusive::pointer_traits` (portable implementation of C++11
    `std::pointer_traits`) or `boost::pointer_to_other` utility from [*Boost SmartPointers]
    defined in `<boost/pointer_to_other.hpp>`.
-   
+  
 *  [*['const_pointer]]: The type of a pointer to a `const value_type`. It must be the same pointer type
    as `node_ptr`: If `node_ptr` is `node*`, `const_pointer` must be `const value_type*`. If
    `node_ptr` is `smart_ptr<node_traits::node>`, `const_pointer` must be `smart_ptr<const value_type>`.
-     
+    
 *  [*['link_mode]]: Indicates that `value_traits` needs some additional work or checks from the
    container. The types are enumerations defined in the `link_mode.hpp` header.
    These are the possible types:
@@ -3138,7 +3138,7 @@
       of the erased values to a default state. Containers also won't
       check that the hooks of the new values are default initialized.
 
-   *  [*`safe_link`]: If this linking policy is specified as the link mode 
+   *  [*`safe_link`]: If this linking policy is specified as the link mode
       in a `ValueTraits` class, containers
       configured with this `ValueTraits` will set the hooks
       of the erased values to a default state. Containers also will
@@ -3165,11 +3165,11 @@
 [section:value_traits_example Custom ValueTraits example]
 
 Let's define our own `value_traits` class to be able to use [*Boost.Intrusive]
-containers with an old C structure whose definition can't be changed. 
+containers with an old C structure whose definition can't be changed.
 That legacy type has two pointers that can be used to build singly and doubly linked
 lists: in singly linked lists we only need a pointer, whereas in doubly
 linked lists, we need two pointers. Since we only have two pointers, we can't insert
-the object in both a singly and a doubly linked list at the same time. 
+the object in both a singly and a doubly linked list at the same time.
 This is the definition of the old node:
 
 [import ../example/doc_value_traits.cpp]
@@ -3181,20 +3181,20 @@
 
 [doc_value_traits_value_traits]
 
-Defining a value traits class that simply defines `value_type` as 
+Defining a value traits class that simply defines `value_type` as
 `legacy_node_traits::node` is a common approach when defining customized
 intrusive containers, so [*Boost.Intrusive] offers a templatized
 [classref boost::intrusive::trivial_value_traits trivial_value_traits] class
 that does exactly what we want:
 
 [c++]
-   
+  
    #include <boost/intrusive/trivial_value_traits.hpp>
 
    //Now we can define legacy_value_traits just with a single line
    using namespace boost::intrusive;
    typedef trivial_value_traits<legacy_node_traits, normal_link> legacy_value_traits;
-   
+  
 
 Now we can just define the containers that will store the legacy abi objects and write
 a little test:
@@ -3211,7 +3211,7 @@
 In the previous example, `legacy_node_traits::node` type and
 `legacy_value_traits::value_type` are the same type, but this is not necessary. It's possible
 to have several `ValueTraits` defining the same `node_traits` type (and thus, the same `node_traits::node`).
-This reduces the number of node algorithm instantiations, but 
+This reduces the number of node algorithm instantiations, but
 now `ValueTraits::to_node_ptr` and `ValueTraits::to_value_ptr` functions need to offer
 conversions between both types. Let's see a small example:
 
@@ -3256,7 +3256,7 @@
 
    using namespace boost::intrusive;
 
-   //Now define the needed value traits using 
+   //Now define the needed value traits using
    typedef derivation_value_traits<value_1, simple_node_traits, normal_link> ValueTraits1;
    typedef derivation_value_traits<value_2, simple_node_traits, normal_link> ValueTraits2;
 
@@ -3279,7 +3279,7 @@
 and values is implemented in terms of static functions]. It's possible to use [*stateful] value traits
 so that we can separate nodes and values and [*avoid modifying types to insert nodes].
 [*Boost.Intrusive] differentiates between stateful and stateless value traits by checking if all
-Node <-> Value transformation functions are static or not (except for Visual 7.1, since overloaded 
+Node <-> Value transformation functions are static or not (except for Visual 7.1, since overloaded
 static function detection is not possible, in this case the implementation checks if the class is empty):
 
 *  If all Node <-> Value transformation functions are static , a [*stateless]
@@ -3373,7 +3373,7 @@
 
    //Implicitly specify constant-time size and size type
    typedef list<T> List2;
-   
+  
 *  Option specifiers lead to long template symbols for classes and functions. Option specifiers themselves
    are verbose and without variadic templates, several default template parameters are assigned for
    non-specified options. Object and debugging information files can grow and compilation times
@@ -3413,7 +3413,7 @@
 
 [*Boost.Intrusive] should be a valuable tool in performance sensitive environments,
 and following this guideline, [*Boost.Intrusive] has been designed to offer well
-known complexity guarantees. Apart from that, some options, like optional 
+known complexity guarantees. Apart from that, some options, like optional
 constant-time, have been designed to offer faster complexity guarantees in some
 functions, like `slist::splice`.
 
@@ -3476,7 +3476,7 @@
 *  They minimize memory allocation/deallocation calls.
 *  They obtain better memory locality.
 
-This section will show performance tests comparing some operations on 
+This section will show performance tests comparing some operations on
 `boost::intrusive::list` and `std::list`:
 
 *  Insertions using `push_back` and container destruction will show the
@@ -3522,7 +3522,7 @@
 `func_ptr_adaptor` is just a functor adaptor to convert function objects taking
 `test_list` objects to function objects taking pointers to them.
 
-You can find the full test code code in the 
+You can find the full test code code in the
 [@../../libs/intrusive/perf/perf_list.cpp perf_list.cpp] source file.
 
 [section:performance_results_push_back Back insertion and destruction]
@@ -3959,11 +3959,11 @@
 
 [*Olaf Krzikalla] would like to thank:
 
-*  [*Markus Schaaf] for pointing out the possibility and the advantages of the derivation 
-approach. 
+*  [*Markus Schaaf] for pointing out the possibility and the advantages of the derivation
+approach.
 
 *  [*Udo Steinbach] for encouragements to present this work for boost, a lot of fixes and
-helpful discussions. 
+helpful discussions.
 
 *  [*Jaap Suter] for the initial hint, which eventually lead to the member value_traits.
 

Modified: trunk/libs/intrusive/example/Jamfile.v2
==============================================================================
--- trunk/libs/intrusive/example/Jamfile.v2	(original)
+++ trunk/libs/intrusive/example/Jamfile.v2	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -1,14 +1,14 @@
 # Boost Intrusive Library Example Jamfile
 
 #  (C) Copyright Ion Gaztanaga 2006-2007.
-# Use, modification and distribution are subject to the 
-# Boost Software License, Version 1.0. (See accompanying file 
+# 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 
+# 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
@@ -27,7 +27,7 @@
       :  # requirements
         <toolset>acc:<linkflags>-lrt
         <toolset>acc-pa_risc:<linkflags>-lrt
-        <toolset>gcc-mingw:<linkflags>"-lole32 -loleaut32" 
+        <toolset>gcc-mingw:<linkflags>"-lole32 -loleaut32"
         <host-os>hpux,<toolset>gcc:<linkflags>"-Wl,+as,mpas"
       ] ;
    }
@@ -35,4 +35,4 @@
    return $(all_rules) ;
 }
 
-test-suite intrusive_example : [ test_all r ] : <threading>multi ; 
\ No newline at end of file
+test-suite intrusive_example : [ test_all r ] : <threading>multi ;

Modified: trunk/libs/intrusive/example/doc_advanced_value_traits.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_advanced_value_traits.cpp	(original)
+++ trunk/libs/intrusive/example/doc_advanced_value_traits.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -14,7 +14,7 @@
 #include <boost/intrusive/list.hpp>
 #include <vector>
 
-//This is the node that will be used with algorithms. 
+//This is the node that will be used with algorithms.
 struct simple_node
 {
    simple_node *prev_;
@@ -26,7 +26,7 @@
 class base_1{};
 class base_2{};
 
-struct value_1 :  public base_1, public simple_node   
+struct value_1 :  public base_1, public simple_node  
 {  int   id_;  };
 
 struct value_2 :  public base_1, public base_2, public simple_node
@@ -38,10 +38,10 @@
    typedef simple_node                             node;
    typedef node *                                  node_ptr;
    typedef const node *                            const_node_ptr;
-   static node *get_next(const node *n)            {  return n->next_;  }  
-   static void set_next(node *n, node *next)       {  n->next_ = next;  }  
-   static node *get_previous(const node *n)        {  return n->prev_;  }  
-   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  }  
+   static node *get_next(const node *n)            {  return n->next_;  } 
+   static void set_next(node *n, node *next)       {  n->next_ = next;  } 
+   static node *get_previous(const node *n)        {  return n->prev_;  } 
+   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  } 
 };
 
 //A templatized value traits for value_1 and value_2

Modified: trunk/libs/intrusive/example/doc_advanced_value_traits2.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_advanced_value_traits2.cpp	(original)
+++ trunk/libs/intrusive/example/doc_advanced_value_traits2.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -26,17 +26,17 @@
    typedef simple_node                             node;
    typedef node *                                  node_ptr;
    typedef const node *                            const_node_ptr;
-   static node *get_next(const node *n)            {  return n->next_;  }  
-   static void set_next(node *n, node *next)       {  n->next_ = next;  }  
-   static node *get_previous(const node *n)        {  return n->prev_;  }  
-   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  }  
+   static node *get_next(const node *n)            {  return n->next_;  } 
+   static void set_next(node *n, node *next)       {  n->next_ = next;  } 
+   static node *get_previous(const node *n)        {  return n->prev_;  } 
+   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  } 
 };
 
 //[doc_advanced_value_traits2_value_traits
 class base_1{};
 class base_2{};
 
-struct value_1 :  public base_1, public simple_node   
+struct value_1 :  public base_1, public simple_node  
 {
    int   id_;
    simple_node node_;

Modified: trunk/libs/intrusive/example/doc_assoc_optimized_code.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_assoc_optimized_code.cpp	(original)
+++ trunk/libs/intrusive/example/doc_assoc_optimized_code.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -20,7 +20,7 @@
 struct StrHasher
 {
    std::size_t operator()(const char *str) const
-   {  
+   { 
       std::size_t seed = 0;
       for(; *str; ++str)   boost::hash_combine(seed, *str);
       return seed;
@@ -31,7 +31,7 @@
 {
    std::string key_;
    // Other members...
-  
+ 
    public:
    Expensive(const char *key)
       :  key_(key)

Modified: trunk/libs/intrusive/example/doc_avl_set.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_avl_set.cpp	(original)
+++ trunk/libs/intrusive/example/doc_avl_set.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -55,10 +55,10 @@
 
    BaseSet baseset;
    MemberMultiset membermultiset;
-   
-   //Check that size optimization is activated in the base hook 
+  
+   //Check that size optimization is activated in the base hook
    assert(sizeof(avl_set_base_hook<optimize_size<true> >) == 3*sizeof(void*));
-   //Check that size optimization is deactivated in the member hook 
+   //Check that size optimization is deactivated in the member hook
    assert(sizeof(avl_set_member_hook<>) > 3*sizeof(void*));
 
    //Now insert them in the sets

Modified: trunk/libs/intrusive/example/doc_avltree_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_avltree_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_avltree_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -32,13 +32,13 @@
    typedef const my_node *                            const_node_ptr;
    typedef int                                        balance;
 
-   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   }  
-   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; }  
-   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     }  
-   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     }  
-   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    }  
-   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   }  
-   static balance get_balance(const_node_ptr n)       {  return n->balance_;  }  
+   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   } 
+   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; } 
+   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     } 
+   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     } 
+   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    } 
+   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   } 
+   static balance get_balance(const_node_ptr n)       {  return n->balance_;  } 
    static void set_balance(node_ptr n, balance b)     {  n->balance_ = b;     }
    static balance negative()                          {  return -1; }
    static balance zero()                              {  return 0;  }
@@ -72,7 +72,7 @@
 
    //Now go to the next node
    n = algo::next_node(n);
-   assert(n == &three);      
+   assert(n == &three);     
 
    //Erase a node just using a pointer to it
    algo::unlink(&two);

Modified: trunk/libs/intrusive/example/doc_entity.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_entity.cpp	(original)
+++ trunk/libs/intrusive/example/doc_entity.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -38,14 +38,14 @@
 
 //Function to insert a new "some_entity" in the global list
 void insert_some_entity()
-{  global_list.push_back (*new some_entity(/*...*/));  } 
+{  global_list.push_back (*new some_entity(/*...*/));  }
 
 //Function to clear an entity from the intrusive global list
 void clear_list ()
 {
    // entity's destructor removes itself from the global list implicitly
    while (!global_list.empty())
-      delete &global_list.front();   
+      delete &global_list.front();  
 }
 
 int main()

Modified: trunk/libs/intrusive/example/doc_external_value_traits.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_external_value_traits.cpp	(original)
+++ trunk/libs/intrusive/example/doc_external_value_traits.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -33,8 +33,8 @@
    typedef node *                            node_ptr;
    typedef const node *                      const_node_ptr;
    typedef identifier_t                      value_type;
-   typedef identifier_t *                    pointer; 
-   typedef const identifier_t *              const_pointer; 
+   typedef identifier_t *                    pointer;
+   typedef const identifier_t *              const_pointer;
    static const link_mode_type link_mode =   normal_link;
 
    external_traits(pointer ids, std::size_t NumElements)
@@ -63,7 +63,7 @@
 struct internal_traits
 {
    static const bool external_value_traits = true;
-   typedef external_traits value_traits; 
+   typedef external_traits value_traits;
 
    template<class Container>
    value_traits &get_value_traits(Container &cont);

Modified: trunk/libs/intrusive/example/doc_list.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_list.cpp	(original)
+++ trunk/libs/intrusive/example/doc_list.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -33,7 +33,7 @@
 
 //Define a list that will store MyClass using the public member hook
 typedef list< MyClass
-            , member_hook< MyClass, list_member_hook<>, &MyClass::member_hook_> 
+            , member_hook< MyClass, list_member_hook<>, &MyClass::member_hook_>
             > MemberList;
 
 int main()

Modified: trunk/libs/intrusive/example/doc_list_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_list_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_list_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -25,10 +25,10 @@
    typedef my_node                                    node;
    typedef my_node *                                  node_ptr;
    typedef const my_node *                            const_node_ptr;
-   static node_ptr get_next(const_node_ptr n)         {  return n->next_;  }  
-   static void set_next(node_ptr n, node_ptr next)    {  n->next_ = next;  }  
-   static node *get_previous(const_node_ptr n)        {  return n->prev_;  }  
-   static void set_previous(node_ptr n, node_ptr prev){  n->prev_ = prev;  }  
+   static node_ptr get_next(const_node_ptr n)         {  return n->next_;  } 
+   static void set_next(node_ptr n, node_ptr next)    {  n->next_ = next;  } 
+   static node *get_previous(const_node_ptr n)        {  return n->prev_;  } 
+   static void set_previous(node_ptr n, node_ptr prev){  n->prev_ = prev;  } 
 };
 
 int main()

Modified: trunk/libs/intrusive/example/doc_offset_ptr.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_offset_ptr.cpp	(original)
+++ trunk/libs/intrusive/example/doc_offset_ptr.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -61,7 +61,7 @@
    const int ShmSize    = 50000;
    const char *ShmName  = get_shared_memory_name();
    {
-      //Erase all old shared memory 
+      //Erase all old shared memory
       ip::shared_memory_object::remove(ShmName);
       ip::managed_shared_memory shm(ip::create_only, ShmName, ShmSize);
 
@@ -72,7 +72,7 @@
             shm_allocator_t;
       typedef ip::vector<shared_memory_data, shm_allocator_t> shm_vector_t;
       shm_allocator_t shm_alloc(shm.get_segment_manager());
-      shm_vector_t *pshm_vect = 
+      shm_vector_t *pshm_vect =
          shm.construct<shm_vector_t>(ip::anonymous_instance)(shm_alloc);
       pshm_vect->resize(MaxElem);
 

Modified: trunk/libs/intrusive/example/doc_rbtree_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_rbtree_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_rbtree_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -31,13 +31,13 @@
    typedef my_node *                                  node_ptr;
    typedef const my_node *                            const_node_ptr;
    typedef int                                        color;
-   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   }  
-   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; }  
-   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     }  
-   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     }  
-   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    }  
-   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   }  
-   static color get_color(const_node_ptr n)           {  return n->color_;    }  
+   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   } 
+   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; } 
+   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     } 
+   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     } 
+   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    } 
+   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   } 
+   static color get_color(const_node_ptr n)           {  return n->color_;    } 
    static void set_color(node_ptr n, color c)         {  n->color_ = c;       }
    static color black()                               {  return color(0);     }
    static color red()                                 {  return color(1);     }
@@ -70,7 +70,7 @@
 
    //Now go to the next node
    n = algo::next_node(n);
-   assert(n == &three);      
+   assert(n == &three);     
 
    //Erase a node just using a pointer to it
    algo::unlink(&two);

Modified: trunk/libs/intrusive/example/doc_set.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_set.cpp	(original)
+++ trunk/libs/intrusive/example/doc_set.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -55,10 +55,10 @@
 
    BaseSet baseset;
    MemberMultiset membermultiset;
-   
-   //Check that size optimization is activated in the base hook 
+  
+   //Check that size optimization is activated in the base hook
    assert(sizeof(set_base_hook<optimize_size<true> >) == 3*sizeof(void*));
-   //Check that size optimization is deactivated in the member hook 
+   //Check that size optimization is deactivated in the member hook
    assert(sizeof(set_member_hook<>) > 3*sizeof(void*));
 
    //Now insert them in the reverse order in the base hook set

Modified: trunk/libs/intrusive/example/doc_sg_set.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_sg_set.cpp	(original)
+++ trunk/libs/intrusive/example/doc_sg_set.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -56,7 +56,7 @@
 
    BaseSet baseset;
    MemberMultiset membermultiset;
-   
+  
    //Now insert them in the reverse order in the base hook sg_set
    for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it){
       baseset.insert(*it);

Modified: trunk/libs/intrusive/example/doc_slist_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_slist_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_slist_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -25,8 +25,8 @@
    typedef my_node                                 node;
    typedef my_node *                               node_ptr;
    typedef const my_node *                         const_node_ptr;
-   static node_ptr get_next(const_node_ptr n)      {  return n->next_;  }  
-   static void set_next(node_ptr n, node_ptr next) {  n->next_ = next;  }  
+   static node_ptr get_next(const_node_ptr n)      {  return n->next_;  } 
+   static void set_next(node_ptr n, node_ptr next) {  n->next_ = next;  } 
 };
 
 int main()

Modified: trunk/libs/intrusive/example/doc_splay_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_splay_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_splay_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -31,12 +31,12 @@
    typedef my_node *                                  node_ptr;
    typedef const my_node *                            const_node_ptr;
 
-   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   }  
-   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; }  
-   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     }  
-   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     }  
-   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    }  
-   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   }  
+   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   } 
+   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; } 
+   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     } 
+   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     } 
+   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    } 
+   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   } 
 };
 
 struct node_ptr_compare
@@ -66,7 +66,7 @@
 
    //Now go to the next node
    n = algo::next_node(n);
-   assert(n == &three);      
+   assert(n == &three);     
 
    //Erase a node just using a pointer to it
    algo::unlink(&two);

Modified: trunk/libs/intrusive/example/doc_splay_set.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_splay_set.cpp	(original)
+++ trunk/libs/intrusive/example/doc_splay_set.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -20,7 +20,7 @@
 class MyClass
    : public splay_set_base_hook<>   //This is an splay tree base hook
    , public bs_set_base_hook<>      //This is a binary search tree base hook
-         
+        
 {
    int int_;
 

Modified: trunk/libs/intrusive/example/doc_splaytree_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_splaytree_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_splaytree_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -30,12 +30,12 @@
    typedef my_node *                                  node_ptr;
    typedef const my_node *                            const_node_ptr;
 
-   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   }  
-   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; }  
-   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     }  
-   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     }  
-   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    }  
-   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   }  
+   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   } 
+   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; } 
+   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     } 
+   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     } 
+   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    } 
+   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   } 
 };
 
 struct node_ptr_compare
@@ -65,7 +65,7 @@
 
    //Now go to the next node
    n = algo::next_node(n);
-   assert(n == &three);      
+   assert(n == &three);     
 
    //Erase a node just using a pointer to it
    algo::unlink(&two);

Modified: trunk/libs/intrusive/example/doc_stateful_value_traits.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_stateful_value_traits.cpp	(original)
+++ trunk/libs/intrusive/example/doc_stateful_value_traits.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -27,8 +27,8 @@
    typedef node *                            node_ptr;
    typedef const node *                      const_node_ptr;
    typedef identifier_t                      value_type;
-   typedef identifier_t *                    pointer; 
-   typedef const identifier_t *              const_pointer; 
+   typedef identifier_t *                    pointer;
+   typedef const identifier_t *              const_pointer;
    static const link_mode_type link_mode =   normal_link;
 
    stateful_value_traits(pointer ids, node_ptr node_array)

Modified: trunk/libs/intrusive/example/doc_treap_algorithms.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_treap_algorithms.cpp	(original)
+++ trunk/libs/intrusive/example/doc_treap_algorithms.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -31,12 +31,12 @@
    typedef my_node *                                  node_ptr;
    typedef const my_node *                            const_node_ptr;
 
-   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   }  
-   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; }  
-   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     }  
-   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     }  
-   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    }  
-   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   }  
+   static node_ptr get_parent(const_node_ptr n)       {  return n->parent_;   } 
+   static void set_parent(node_ptr n, node_ptr parent){  n->parent_ = parent; } 
+   static node_ptr get_left(const_node_ptr n)         {  return n->left_;     } 
+   static void set_left(node_ptr n, node_ptr left)    {  n->left_ = left;     } 
+   static node_ptr get_right(const_node_ptr n)        {  return n->right_;    } 
+   static void set_right(node_ptr n, node_ptr right)  {  n->right_ = right;   } 
 };
 
 struct node_ptr_compare
@@ -66,7 +66,7 @@
 
    //Now go to the next node
    n = algo::next_node(n);
-   assert(n == &three);      
+   assert(n == &three);     
 
    //Erase a node just using a pointer to it
    algo::unlink(&two, node_ptr_priority());

Modified: trunk/libs/intrusive/example/doc_treap_set.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_treap_set.cpp	(original)
+++ trunk/libs/intrusive/example/doc_treap_set.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -70,7 +70,7 @@
 
    BaseSet baseset;
    MemberMultiset membermultiset;
-   
+  
    //Now insert them in the sets
    for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it){
       baseset.insert(*it);

Modified: trunk/libs/intrusive/example/doc_value_traits.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_value_traits.cpp	(original)
+++ trunk/libs/intrusive/example/doc_value_traits.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -17,7 +17,7 @@
 
 //This node is the legacy type we can't modify and we want to insert in
 //intrusive list and slist containers using only two pointers, since
-//we know the object will never be at the same time in both lists. 
+//we know the object will never be at the same time in both lists.
 struct legacy_value
 {
    legacy_value *prev_;
@@ -39,14 +39,14 @@
    typedef legacy_value *                          node_ptr;
    typedef const legacy_value *                    const_node_ptr;
 
-   static node *get_next(const node *n)            {  return n->next_;  }  
-   static void set_next(node *n, node *next)       {  n->next_ = next;  }  
-   static node *get_previous(const node *n)        {  return n->prev_;  }  
-   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  }  
+   static node *get_next(const node *n)            {  return n->next_;  } 
+   static void set_next(node *n, node *next)       {  n->next_ = next;  } 
+   static node *get_previous(const node *n)        {  return n->prev_;  } 
+   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  } 
 };
 
 //This ValueTraits will configure list and slist. In this case,
-//legacy_node_traits::node is the same as the 
+//legacy_node_traits::node is the same as the
 //legacy_value_traits::value_type so to_node_ptr/to_value_ptr
 //functions are trivial.
 struct legacy_value_traits

Modified: trunk/libs/intrusive/example/doc_window.cpp
==============================================================================
--- trunk/libs/intrusive/example/doc_window.cpp	(original)
+++ trunk/libs/intrusive/example/doc_window.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -27,7 +27,7 @@
    //Constructor. Includes this window in the list
    Window()             {  all_windows.push_back(*this);  }
    //Destructor. Removes this node from the list
-   virtual ~Window()    {  all_windows.erase(win_list::s_iterator_to(*this));  } 
+   virtual ~Window()    {  all_windows.erase(win_list::s_iterator_to(*this));  }
    //Pure virtual function to be implemented by derived classes
    virtual void Paint() = 0;
 };
@@ -75,7 +75,7 @@
    MainWindow window;
 
    //Paint all the windows, sub-windows and so on
-   paint_all_windows(); 
+   paint_all_windows();
 
    //All the windows are automatically unregistered in their destructors.
    return 0;

Modified: trunk/libs/intrusive/perf/Jamfile.v2
==============================================================================
--- trunk/libs/intrusive/perf/Jamfile.v2	(original)
+++ trunk/libs/intrusive/perf/Jamfile.v2	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -1,14 +1,14 @@
 # Boost Intrusive Library Performance test Jamfile
 
 #  (C) Copyright Ion Gaztanaga 2006-2007.
-# Use, modification and distribution are subject to the 
-# Boost Software License, Version 1.0. (See accompanying file 
+# 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 
+# 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
@@ -21,7 +21,7 @@
 
    for local fileb in [ glob *.cpp ]
    {
-      all_rules += [ run $(fileb) 
+      all_rules += [ run $(fileb)
       :  # additional args
       :  # test-files
       :  # requirements
@@ -31,4 +31,4 @@
    return $(all_rules) ;
 }
 
-test-suite intrusive_perf : [ test_all r ] ; 
\ No newline at end of file
+test-suite intrusive_perf : [ test_all r ] ;

Modified: trunk/libs/intrusive/proj/vc7ide/to-do.txt
==============================================================================
--- trunk/libs/intrusive/proj/vc7ide/to-do.txt	(original)
+++ trunk/libs/intrusive/proj/vc7ide/to-do.txt	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -28,6 +28,6 @@
 
 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1456.html
 
-Now, intrusive containers don't allocate memory at all, so incremental rehashing must be trigered by the user using 
+Now, intrusive containers don't allocate memory at all, so incremental rehashing must be trigered by the user using
 "incremental_rehash(bool)" (use an additional bucket, that is, incremental rehash) and "incremental_rehash(bucket_traits)" (to update the new bucket array with an array that should be twice/half the size of the previous one). I admit that this is not explained at all with an example, so I will note this issue in my to do list.
 

Modified: trunk/libs/intrusive/test/Jamfile.v2
==============================================================================
--- trunk/libs/intrusive/test/Jamfile.v2	(original)
+++ trunk/libs/intrusive/test/Jamfile.v2	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -1,13 +1,13 @@
 # Boost Intrusive Library Test Jamfile
 #  (C) Copyright Ion Gaztanaga 2006.
-# Use, modification and distribution are subject to the 
-# Boost Software License, Version 1.0. (See accompanying file 
+# 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 
+# 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
@@ -26,7 +26,7 @@
       :  # requirements
         <toolset>acc:<linkflags>-lrt
         <toolset>acc-pa_risc:<linkflags>-lrt
-        <toolset>gcc-mingw:<linkflags>"-lole32 -loleaut32" 
+        <toolset>gcc-mingw:<linkflags>"-lole32 -loleaut32"
         <host-os>hpux,<toolset>gcc:<linkflags>"-Wl,+as,mpas"
       ] ;
    }

Modified: trunk/libs/intrusive/test/avl_multiset_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/avl_multiset_test.cpp	(original)
+++ trunk/libs/intrusive/test/avl_multiset_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -24,7 +24,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::avl_multiset<T, 
+struct has_insert_before<boost::intrusive::avl_multiset<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -146,7 +146,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/avl_set_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/avl_set_test.cpp	(original)
+++ trunk/libs/intrusive/test/avl_set_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -23,7 +23,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::avl_set<T, 
+struct has_insert_before<boost::intrusive::avl_set<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -147,7 +147,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/common_functors.hpp
==============================================================================
--- trunk/libs/intrusive/test/common_functors.hpp	(original)
+++ trunk/libs/intrusive/test/common_functors.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -29,7 +29,7 @@
    {
       typedef typename std::iterator_traits<Pointer>::value_type value_type;
       BOOST_INTRUSIVE_INVARIANT_ASSERT(( detail::is_same<T, value_type>::value ));
-      delete boost::intrusive::detail::to_raw_pointer(p); 
+      delete boost::intrusive::detail::to_raw_pointer(p);
    }
 };
 

Modified: trunk/libs/intrusive/test/external_value_traits_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/external_value_traits_test.cpp	(original)
+++ trunk/libs/intrusive/test/external_value_traits_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -56,16 +56,16 @@
       :  values_(values),  node_array_(NumElem)
    {}
 
-   node_ptr to_node_ptr (value_type &value) 
+   node_ptr to_node_ptr (value_type &value)
    {  return (&node_array_[0]) + (&value - values_); }
 
-   const_node_ptr to_node_ptr (const value_type &value) const 
+   const_node_ptr to_node_ptr (const value_type &value) const
    {  return &node_array_[0] + (&value - values_); }
 
    pointer to_value_ptr(node_ptr n)
    {  return values_ + (n - &node_array_[0]); }
 
-   const_pointer to_value_ptr(const_node_ptr n) const 
+   const_pointer to_value_ptr(const_node_ptr n) const
    {  return values_ + (n - &node_array_[0]); }
 
    pointer  values_;

Modified: trunk/libs/intrusive/test/generic_assoc_test.hpp
==============================================================================
--- trunk/libs/intrusive/test/generic_assoc_test.hpp	(original)
+++ trunk/libs/intrusive/test/generic_assoc_test.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -42,7 +42,7 @@
 };
 
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
-struct test_generic_assoc 
+struct test_generic_assoc
 {
    typedef typename ValueTraits::value_type value_type;
    static void test_all(std::vector<value_type>& values);
@@ -134,7 +134,7 @@
       typedef typename std::vector<value_type>::const_iterator cvec_iterator;
       //Random erasure
       std::vector<cvec_iterator> it_vector;
-      
+     
       for(cvec_iterator it(values.begin()), itend(values.end())
          ; it != itend
          ; ++it){
@@ -396,7 +396,7 @@
    {
       assoc_type testset;
       typedef typename std::vector<value_type>::iterator vec_iterator;
-      
+     
       for(vec_iterator it(--values.end()); true; --it){
          testset.push_front(*it);
        if(it == values.begin()){

Modified: trunk/libs/intrusive/test/generic_multiset_test.hpp
==============================================================================
--- trunk/libs/intrusive/test/generic_multiset_test.hpp	(original)
+++ trunk/libs/intrusive/test/generic_multiset_test.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -42,7 +42,7 @@
    static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
    std::vector<value_type> values (6);
    for (int i = 0; i < 6; ++i)
-      values[i].value_ = random_init[i]; 
+      values[i].value_ = random_init[i];
 
    typedef typename ContainerDefiner
       < value_type
@@ -77,7 +77,7 @@
    typedef typename ValueTraits::value_type value_type;
    std::vector<value_type> values (5);
    for (int i = 0; i < 5; ++i)
-      values[i].value_ = i; 
+      values[i].value_ = i;
    typedef typename ValueTraits::value_type value_type;
    typedef typename ContainerDefiner
       < value_type
@@ -92,7 +92,7 @@
    testset.erase (testset.iterator_to (values[0]));
    testset.erase (testset.iterator_to (values[1]));
    testset.insert (values[1]);
-     
+    
    testset.erase (testset.iterator_to (values[2]));
    testset.erase (testset.iterator_to (values[3]));
 }
@@ -127,8 +127,8 @@
 
    BOOST_TEST (testset2.begin()->value_ == 2);
    BOOST_TEST (testset2.rbegin()->value_ == 5);
-}  
-  
+} 
+ 
 //test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
 void test_generic_multiset<ValueTraits, ContainerDefiner>::test_insert(std::vector<typename ValueTraits::value_type>& values)
@@ -165,7 +165,7 @@
 
    {  int init_values [] = { 1, 3, 5 };
       TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() );  }
-}  
+} 
 
 //test: insert (seq-version), swap, erase (seq-version), size:
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
@@ -191,7 +191,7 @@
    testset1.erase (testset1.iterator_to(values[5]), testset1.end());
    BOOST_TEST (testset1.size() == 1);
    BOOST_TEST (&*testset1.begin() == &values[3]);
-}  
+} 
 
 //test: find, equal_range (lower_bound, upper_bound):
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
@@ -213,14 +213,14 @@
    BOOST_TEST (i->value_ == 2);
    BOOST_TEST ((++i)->value_ == 2);
    std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
-     
+    
    BOOST_TEST (range.first->value_ == 2);
    BOOST_TEST (range.second->value_ == 3);
    BOOST_TEST (std::distance (range.first, range.second) == 2);
 
    cmp_val.value_ = 7;
    BOOST_TEST (testset.find (cmp_val) == testset.end());
-} 
+}
 
 }}}   //namespace boost::intrusive::test
 

Modified: trunk/libs/intrusive/test/generic_set_test.hpp
==============================================================================
--- trunk/libs/intrusive/test/generic_set_test.hpp	(original)
+++ trunk/libs/intrusive/test/generic_set_test.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -30,7 +30,7 @@
 };
 
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
-struct test_generic_set 
+struct test_generic_set
 {
    typedef typename ValueTraits::value_type value_type;
    static void test_all();
@@ -52,7 +52,7 @@
    static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
    std::vector<value_type> values (6);
    for (int i = 0; i < 6; ++i)
-      values[i].value_ = random_init[i]; 
+      values[i].value_ = random_init[i];
 
    typedef typename ContainerDefiner
       < value_type
@@ -88,7 +88,7 @@
    typedef typename ValueTraits::value_type value_type;
    std::vector<value_type> values (5);
    for (int i = 0; i < 5; ++i)
-      values[i].value_ = i; 
+      values[i].value_ = i;
 
    typedef typename ValueTraits::value_type value_type;
    typedef typename ContainerDefiner
@@ -103,7 +103,7 @@
    testset.erase (testset.iterator_to (values[0]));
    testset.erase (testset.iterator_to (values[1]));
    testset.insert (values[1]);
-     
+    
    testset.erase (testset.iterator_to (values[2]));
    testset.erase (testset.iterator_to (values[3]));
 }
@@ -137,8 +137,8 @@
       TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() );  }
    BOOST_TEST (testset2.begin()->value_ == 2);
    BOOST_TEST (testset2.rbegin()->value_ == 5);
-}  
-  
+} 
+ 
 //test: insert, const_iterator, const_reverse_iterator, erase, s_iterator_to:
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
 void test_generic_set<ValueTraits, ContainerDefiner>::test_insert(std::vector<typename ValueTraits::value_type>& values)
@@ -263,7 +263,7 @@
    BOOST_TEST (testset1.size() == 1);
    //  BOOST_TEST (&testset1.front() == &values[3]);
    BOOST_TEST (&*testset1.begin() == &values[3]);
-}  
+} 
 
 //test: find, equal_range (lower_bound, upper_bound):
 template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
@@ -284,14 +284,14 @@
    BOOST_TEST (i->value_ == 2);
    BOOST_TEST ((++i)->value_ != 2);
    std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
-     
+    
    BOOST_TEST (range.first->value_ == 2);
    BOOST_TEST (range.second->value_ == 3);
    BOOST_TEST (std::distance (range.first, range.second) == 1);
 
    cmp_val.value_ = 7;
    BOOST_TEST (testset.find (cmp_val) == testset.end());
-} 
+}
 
 }}}   //namespace boost::intrusive::test
 

Modified: trunk/libs/intrusive/test/has_member_function_callable_with.cpp
==============================================================================
--- trunk/libs/intrusive/test/has_member_function_callable_with.cpp	(original)
+++ trunk/libs/intrusive/test/has_member_function_callable_with.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -31,14 +31,14 @@
    private_type const &operator,(int) const;
 };
 
-typedef char yes_type;      
+typedef char yes_type;     
 struct no_type{ char dummy[2]; };
 
 template<typename T>
 no_type is_private_type(T const &);
 yes_type is_private_type(private_type const &);
 
-}}}}  
+}}}} 
 
 
 namespace boost{
@@ -121,9 +121,9 @@
             template<class U>
             static zeroarg_checker_func<U> Test(zeroarg_checker_func<U>*);
 
-            template <class U> 
+            template <class U>
             static has_member_function_callable_with::no_type Test(...);
-            
+           
             static const bool value
                = sizeof(Test< Fun >(0)) == sizeof(has_member_function_callable_with::yes_type);
          };
@@ -186,7 +186,7 @@
                                  );
    };
 
-   }}}  
+   }}} 
 
    namespace boost{
    namespace intrusive{
@@ -216,7 +216,7 @@
                                        )
                                  );
    };
-   }}}  
+   }}} 
 
    namespace boost{
    namespace intrusive{
@@ -306,9 +306,9 @@
       template<class U>
       static zeroarg_checker_func<U> Test(zeroarg_checker_func<U>*);
 
-      template <class U> 
+      template <class U>
       static has_member_function_callable_with::no_type Test(...);
-      
+     
       static const bool value = sizeof(Test< Fun >(0))
                            == sizeof(has_member_function_callable_with::yes_type);
    };
@@ -460,7 +460,7 @@
    (void)check5;
    (void)check6;
    (void)check7;
-   }   
+   }  
 
    return 0;
 

Modified: trunk/libs/intrusive/test/itestvalue.hpp
==============================================================================
--- trunk/libs/intrusive/test/itestvalue.hpp	(original)
+++ trunk/libs/intrusive/test/itestvalue.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -141,7 +141,7 @@
          return v1.value_ < v2.value_;
       else
          return v2.value_ & 1;
-   }  
+   } 
 };
 
 struct is_even
@@ -149,7 +149,7 @@
    template<class Hooks, bool constant_time_size>
    bool operator()
       (const testvalue<Hooks, constant_time_size>& v1) const
-   {  return (v1.value_ & 1) == 0;  }  
+   {  return (v1.value_ & 1) == 0;  } 
 };
 /*
 struct int_testvalue_comp

Modified: trunk/libs/intrusive/test/list_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/list_test.cpp	(original)
+++ trunk/libs/intrusive/test/list_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -37,7 +37,7 @@
 };
 
 template<class ValueTraits>
-struct test_list 
+struct test_list
 {
    typedef typename ValueTraits::value_type value_type;
    static void test_all(std::vector<value_type>& values);
@@ -114,7 +114,7 @@
 
    testlist.pop_front();
    BOOST_TEST (testlist.empty());
-}  
+} 
 
 
 //test: constructor, iterator, reverse_iterator, sort, reverse:
@@ -196,7 +196,7 @@
    int init_values [] = { 1, 3, 4, 5 };
    TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() );
 }
-  
+ 
 //test: assign, insert, const_iterator, const_reverse_iterator, erase, s_iterator_to:
 template<class ValueTraits>
 void test_list<ValueTraits>
@@ -281,7 +281,7 @@
          testlist.clear();
       }
    }
-} 
+}
 
 //test: insert (seq-version), swap, splice, erase (seq-version):
 template<class ValueTraits>
@@ -319,7 +319,7 @@
       {  int init_values [] = { 1, 3, 5, 2 };
          TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() );  }
 
-      testlist1.splice (testlist1.end(), testlist2, 
+      testlist1.splice (testlist1.end(), testlist2,
                         testlist2.begin(), ----testlist2.end());
       {  int init_values [] = { 4, 1, 3 };
          TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() );  }
@@ -414,7 +414,7 @@
       typedef testvalue<hooks<VoidPointer>, constant_time_size> value_type;
       std::vector<value_type> data (5);
       for (int i = 0; i < 5; ++i)
-         data[i].value_ = i + 1; 
+         data[i].value_ = i + 1;
 
       test_list < typename detail::get_base_value_traits
                   < value_type
@@ -442,7 +442,7 @@
       typedef testvalue<hooks<VoidPointer>, false> value_type;
       std::vector<value_type> data (5);
       for (int i = 0; i < 5; ++i)
-         data[i].value_ = i + 1; 
+         data[i].value_ = i + 1;
 
       test_list < typename detail::get_base_value_traits
                   < value_type
@@ -489,7 +489,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/multiset_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/multiset_test.cpp	(original)
+++ trunk/libs/intrusive/test/multiset_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -23,7 +23,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::multiset<T, 
+struct has_insert_before<boost::intrusive::multiset<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -145,7 +145,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/recursive_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/recursive_test.cpp	(original)
+++ trunk/libs/intrusive/test/recursive_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -49,7 +49,7 @@
    list< Foo, base_hook<ListBaseHook> >   list_;   list_.clear();
    slist< Foo, base_hook<SListBaseHook> > slist_;  slist_.clear();
    set< Foo, base_hook<SetBaseHook> > set_;  set_.clear();
-   
+  
    USet::bucket_type buckets[1];
    USet unordered_set_(USet::bucket_traits(buckets, 1));  unordered_set_.clear();
 }

Modified: trunk/libs/intrusive/test/set_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/set_test.cpp	(original)
+++ trunk/libs/intrusive/test/set_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -24,7 +24,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::set<T, 
+struct has_insert_before<boost::intrusive::set<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -148,7 +148,7 @@
 };
 
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/sg_multiset_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/sg_multiset_test.cpp	(original)
+++ trunk/libs/intrusive/test/sg_multiset_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -40,7 +40,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::sg_multiset<T, 
+struct has_insert_before<boost::intrusive::sg_multiset<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -143,7 +143,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*>()();
    test_main_template<boost::intrusive::smart_ptr<void> >()();

Modified: trunk/libs/intrusive/test/sg_set_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/sg_set_test.cpp	(original)
+++ trunk/libs/intrusive/test/sg_set_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -22,7 +22,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_rebalance<boost::intrusive::sg_set<T, 
+struct has_rebalance<boost::intrusive::sg_set<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -38,7 +38,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::sg_set<T, 
+struct has_insert_before<boost::intrusive::sg_set<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -142,7 +142,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*>()();
    test_main_template<boost::intrusive::smart_ptr<void> >()();

Modified: trunk/libs/intrusive/test/slist_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/slist_test.cpp	(original)
+++ trunk/libs/intrusive/test/slist_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -38,7 +38,7 @@
 };
 
 template<class ValueTraits, bool Linear, bool CacheLast>
-struct test_slist 
+struct test_slist
 {
    typedef typename ValueTraits::value_type value_type;
    static void test_all(std::vector<value_type>& values);
@@ -106,7 +106,7 @@
       > list_type;
    list_type testlist;
    BOOST_TEST (testlist.empty());
-     
+    
    testlist.push_front (values[0]);
    BOOST_TEST (testlist.size() == 1);
    BOOST_TEST (&testlist.front() == &values[0]);
@@ -114,11 +114,11 @@
    testlist.push_front (values[1]);
    BOOST_TEST (testlist.size() == 2);
    BOOST_TEST (&testlist.front() == &values[1]);
-     
+    
    testlist.pop_front();
    BOOST_TEST (testlist.size() == 1);
    BOOST_TEST (&testlist.front() == &values[0]);
-     
+    
    testlist.pop_front();
    BOOST_TEST (testlist.empty());
 }
@@ -241,8 +241,8 @@
    testlist.reverse();
    {  int init_values [] = { 5, 3, 1, 4, 2 };
       TEST_INTRUSIVE_SEQUENCE( init_values, testlist.begin() );  }
-}  
-  
+} 
+ 
 //test: assign, insert_after, const_iterator, erase_after, s_iterator_to, previous:
 template<class ValueTraits, bool Linear, bool CacheLast>
 void test_slist<ValueTraits, Linear, CacheLast>
@@ -374,7 +374,7 @@
          testlist.clear();
       }
    }
-}  
+} 
 
 //test: insert_after (seq-version), swap, splice_after:
 template<class ValueTraits, bool Linear, bool CacheLast>
@@ -410,7 +410,7 @@
       {  int init_values [] = { 1, 3, 5, 2 };
          TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() );  }
 
-      testlist1.splice_after (testlist1.begin(), testlist2, 
+      testlist1.splice_after (testlist1.begin(), testlist2,
                               testlist2.before_begin(), ++++testlist2.begin());
       {  int init_values [] = { 4, 1, 3, 5 };
          TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() );  }
@@ -476,7 +476,7 @@
       {  int init_values [] = { 1 };
          TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() );  }
    }
-}  
+} 
 
 template<class ValueTraits, bool Linear, bool CacheLast>
 void test_slist<ValueTraits, Linear, CacheLast>
@@ -529,7 +529,7 @@
       typedef testvalue<hooks<VoidPointer> , constant_time_size> value_type;
       std::vector<value_type> data (5);
       for (int i = 0; i < 5; ++i)
-         data[i].value_ = i + 1; 
+         data[i].value_ = i + 1;
 
       test_slist < typename detail::get_base_value_traits
                   < value_type
@@ -620,7 +620,7 @@
       typedef testvalue<hooks<VoidPointer> , false> value_type;
       std::vector<value_type> data (5);
       for (int i = 0; i < 5; ++i)
-         data[i].value_ = i + 1; 
+         data[i].value_ = i + 1;
 
       test_slist < typename detail::get_base_value_traits
                   < value_type
@@ -721,7 +721,7 @@
    }
 };
 
-int main(int, char* []) 
+int main(int, char* [])
 {
    test_main_template<void*, false>()();
    test_main_template<smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/smart_ptr.hpp
==============================================================================
--- trunk/libs/intrusive/test/smart_ptr.hpp	(original)
+++ trunk/libs/intrusive/test/smart_ptr.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -37,8 +37,8 @@
 
 template<class T>
 struct random_it
-: public boost::iterator<std::random_access_iterator_tag, 
-                         T, std::ptrdiff_t, T*, T&> 
+: public boost::iterator<std::random_access_iterator_tag,
+                         T, std::ptrdiff_t, T*, T&>
 {
    typedef const T*           const_pointer;
    typedef const T&           const_reference;
@@ -121,11 +121,11 @@
 
    //!Constructor from other pointer. Never throws.
    template <class T>
-   smart_ptr(T *ptr) 
+   smart_ptr(T *ptr)
       :  m_ptr(ptr)
    {}
 */
-   //!Constructor from other smart_ptr 
+   //!Constructor from other smart_ptr
    smart_ptr(const smart_ptr& ptr)
       :  m_ptr(ptr.m_ptr)
    {}
@@ -133,10 +133,10 @@
    static smart_ptr pointer_to(reference r)
    {  smart_ptr p; p.m_ptr = &r; return p;  }
 
-   //!Constructor from other smart_ptr. If pointers of pointee types are 
+   //!Constructor from other smart_ptr. If pointers of pointee types are
    //!convertible, offset_ptrs will be convertibles. Never throws.
    template<class T2>
-   smart_ptr(const smart_ptr<T2> &ptr) 
+   smart_ptr(const smart_ptr<T2> &ptr)
       :  m_ptr(ptr.m_ptr)
    {}
 /*
@@ -169,16 +169,16 @@
    {  return m_ptr;   }
 */
    //!Pointer-like -> operator. It can return 0 pointer. Never throws.
-   pointer operator->() const           
+   pointer operator->() const          
    {  return m_ptr; }
 
-   //!Dereferencing operator, if it is a null smart_ptr behavior 
+   //!Dereferencing operator, if it is a null smart_ptr behavior
    //!   is undefined. Never throws.
-   reference operator* () const           
+   reference operator* () const          
    {  return *m_ptr;   }
 
    //!Indexing operator. Never throws.
-   reference operator[](std::ptrdiff_t idx) const   
+   reference operator[](std::ptrdiff_t idx) const  
    {  return m_ptr[idx];  }
 /*
    //!Assignment from pointer (saves extra conversion). Never throws.
@@ -189,14 +189,14 @@
    smart_ptr& operator= (const smart_ptr & pt)
    {  m_ptr = pt.m_ptr;  return *this;  }
 
-   //!Assignment from related smart_ptr. If pointers of pointee types 
+   //!Assignment from related smart_ptr. If pointers of pointee types
    //!   are assignable, offset_ptrs will be assignable. Never throws.
    template <class T2>
    smart_ptr& operator= (const smart_ptr<T2> & pt)
    {  m_ptr = pt.m_ptr;  return *this;  }
- 
+
    //!smart_ptr + std::ptrdiff_t. Never throws.
-   smart_ptr operator+ (std::ptrdiff_t offset) const   
+   smart_ptr operator+ (std::ptrdiff_t offset) const  
    {  smart_ptr s; s.m_ptr = m_ptr + offset; return s;   }
 
    //!smart_ptr - std::ptrdiff_t. Never throws.
@@ -212,7 +212,7 @@
    {  m_ptr -= offset;  return *this;  }
 
    //!++smart_ptr. Never throws.
-   smart_ptr& operator++ (void) 
+   smart_ptr& operator++ (void)
    {  ++m_ptr;   return *this;  }
 
    //!smart_ptr++. Never throws.
@@ -220,7 +220,7 @@
    {  smart_ptr temp(*this); ++*this; return temp; }
 
    //!--smart_ptr. Never throws.
-   smart_ptr& operator-- (void) 
+   smart_ptr& operator-- (void)
    {  --m_ptr;   return *this;  }
 
    //!smart_ptr--. Never throws.
@@ -228,16 +228,16 @@
    {  smart_ptr temp(*this); --*this; return temp; }
 
    //!safe bool conversion operator. Never throws.
-   operator unspecified_bool_type() const  
+   operator unspecified_bool_type() const 
    {  return m_ptr? &self_t::unspecified_bool_type_func : 0;   }
 
-   //!Not operator. Not needed in theory, but improves portability. 
+   //!Not operator. Not needed in theory, but improves portability.
    //!Never throws.
    bool operator! () const
    {  return m_ptr == 0;   }
 /*
    friend void swap (smart_ptr &pt, smart_ptr &pt2)
-   {  
+   { 
       value_type *ptr = pt.get();
       pt = pt2;
       pt2 = ptr;
@@ -247,102 +247,102 @@
 
 //!smart_ptr<T1> == smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator== (const smart_ptr<T1> &pt1, 
+inline bool operator== (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 {  return pt1.operator->() == pt2.operator->();  }
 
 //!smart_ptr<T1> != smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator!= (const smart_ptr<T1> &pt1, 
+inline bool operator!= (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 {  return pt1.operator->() != pt2.operator->();  }
 
 //!smart_ptr<T1> < smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator< (const smart_ptr<T1> &pt1, 
+inline bool operator< (const smart_ptr<T1> &pt1,
                        const smart_ptr<T2> &pt2)
 {  return pt1.operator->() < pt2.operator->();  }
 
 //!smart_ptr<T1> <= smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator<= (const smart_ptr<T1> &pt1, 
+inline bool operator<= (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 {  return pt1.operator->() <= pt2.operator->();  }
 
 //!smart_ptr<T1> > smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator> (const smart_ptr<T1> &pt1, 
+inline bool operator> (const smart_ptr<T1> &pt1,
                        const smart_ptr<T2> &pt2)
 {  return pt1.operator->() > pt2.operator->();  }
 
 //!smart_ptr<T1> >= smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator>= (const smart_ptr<T1> &pt1, 
+inline bool operator>= (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 {  return pt1.operator->() >= pt2.operator->();  }
 
-//!operator<< 
-template<class E, class T, class Y> 
-inline std::basic_ostream<E, T> & operator<< 
+//!operator<<
+template<class E, class T, class Y>
+inline std::basic_ostream<E, T> & operator<<
    (std::basic_ostream<E, T> & os, smart_ptr<Y> const & p)
 {  return os << p.operator->();   }
 
-//!operator>> 
-template<class E, class T, class Y> 
-inline std::basic_istream<E, T> & operator>> 
+//!operator>>
+template<class E, class T, class Y>
+inline std::basic_istream<E, T> & operator>>
    (std::basic_istream<E, T> & os, smart_ptr<Y> & p)
 {  Y * tmp; return os >> tmp; p = tmp;   }
 
-//!std::ptrdiff_t + smart_ptr  
+//!std::ptrdiff_t + smart_ptr 
 template<class T>
 inline smart_ptr<T> operator+(std::ptrdiff_t diff, const smart_ptr<T>& right)
 {  return right + diff;  }
 
-//!smart_ptr - smart_ptr  
+//!smart_ptr - smart_ptr 
 template<class T, class T2>
 inline std::ptrdiff_t operator- (const smart_ptr<T> &pt, const smart_ptr<T2> &pt2)
 {  return pt.operator->()- pt2.operator->();   }
 
-//!swap specialization 
+//!swap specialization
 template<class T>
-inline void swap (smart_ptr<T> &pt, 
+inline void swap (smart_ptr<T> &pt,
                   smart_ptr<T> &pt2)
-{  
+{ 
    typename smart_ptr<T>::value_type *ptr = pt.operator->();
    pt = pt2;
    pt2 = ptr;
 }
 
 //!Simulation of static_cast between pointers. Never throws.
-template<class T, class U> 
-inline smart_ptr<T> 
+template<class T, class U>
+inline smart_ptr<T>
    static_pointer_cast(const smart_ptr<U> & r)
-{  
-   return smart_ptr<T>(r, detail::static_cast_tag());  
+{ 
+   return smart_ptr<T>(r, detail::static_cast_tag()); 
 }
 
 //!Simulation of const_cast between pointers. Never throws.
-template<class T, class U> 
+template<class T, class U>
 inline smart_ptr<T>const_pointer_cast(smart_ptr<U> const & r)
-{  
-   return smart_ptr<T>(r, detail::const_cast_tag());  
+{ 
+   return smart_ptr<T>(r, detail::const_cast_tag()); 
 }
 
 //!Simulation of dynamic_cast between pointers. Never throws.
-template<class T, class U> 
-inline smart_ptr<T> 
+template<class T, class U>
+inline smart_ptr<T>
    dynamic_pointer_cast(smart_ptr<U> const & r)
-{  
+{ 
    return smart_ptr<T>
-            (r, detail::dynamic_cast_tag());  
+            (r, detail::dynamic_cast_tag()); 
 }
 
 //!Simulation of reinterpret_cast between pointers. Never throws.
-template<class T, class U> 
+template<class T, class U>
 inline smart_ptr<T>
    reinterpret_pointer_cast(smart_ptr<U> const & r)
-{  
-   return smart_ptr<T>(r, detail::reinterpret_cast_tag());  
+{ 
+   return smart_ptr<T>(r, detail::reinterpret_cast_tag()); 
 }
 
 }  //namespace intrusive {

Modified: trunk/libs/intrusive/test/splay_multiset_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/splay_multiset_test.cpp	(original)
+++ trunk/libs/intrusive/test/splay_multiset_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -41,7 +41,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_splay<boost::intrusive::splay_multiset<T, 
+struct has_splay<boost::intrusive::splay_multiset<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -57,7 +57,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_rebalance<boost::intrusive::splay_multiset<T, 
+struct has_rebalance<boost::intrusive::splay_multiset<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -177,7 +177,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/splay_set_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/splay_set_test.cpp	(original)
+++ trunk/libs/intrusive/test/splay_set_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -175,7 +175,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/stateful_value_traits_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/stateful_value_traits_test.cpp	(original)
+++ trunk/libs/intrusive/test/stateful_value_traits_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -57,16 +57,16 @@
       :  values_(values),  node_array_(node_array)
    {}
 
-   node_ptr to_node_ptr (value_type &value) 
+   node_ptr to_node_ptr (value_type &value)
    {  return node_array_ + (&value - values_); }
 
-   const_node_ptr to_node_ptr (const value_type &value) const 
+   const_node_ptr to_node_ptr (const value_type &value) const
    {  return node_array_ + (&value - values_); }
 
    pointer to_value_ptr(node_ptr n)
    {  return values_ + (n - node_array_); }
 
-   const_pointer to_value_ptr(const_node_ptr n) const 
+   const_pointer to_value_ptr(const_node_ptr n) const
    {  return values_ + (n - node_array_); }
 
    pointer  values_;

Modified: trunk/libs/intrusive/test/test_container.hpp
==============================================================================
--- trunk/libs/intrusive/test/test_container.hpp	(original)
+++ trunk/libs/intrusive/test/test_container.hpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -247,7 +247,7 @@
       {
          BOOST_TEST( c.find(*di) != c.end() );
       }
-   
+  
       typename Data::const_iterator db = d.begin();
       typename Data::const_iterator da = db++;
 

Modified: trunk/libs/intrusive/test/treap_multiset_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/treap_multiset_test.cpp	(original)
+++ trunk/libs/intrusive/test/treap_multiset_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -24,7 +24,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::treap_multiset<T, 
+struct has_insert_before<boost::intrusive::treap_multiset<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -143,7 +143,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/treap_set_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/treap_set_test.cpp	(original)
+++ trunk/libs/intrusive/test/treap_set_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -22,7 +22,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct has_insert_before<boost::intrusive::treap_set<T, 
+struct has_insert_before<boost::intrusive::treap_set<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -38,7 +38,7 @@
 #else
 template<class T, class ...Options>
 #endif
-struct is_treap<boost::intrusive::treap_set<T, 
+struct is_treap<boost::intrusive::treap_set<T,
    #if !defined (BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
    O1, O2, O3, O4
    #else
@@ -159,7 +159,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false>()();
    test_main_template<boost::intrusive::smart_ptr<void>, false>()();

Modified: trunk/libs/intrusive/test/unordered_multiset_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/unordered_multiset_test.cpp	(original)
+++ trunk/libs/intrusive/test/unordered_multiset_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -144,7 +144,7 @@
 
    std::vector<value_type> values (5);
    for (int i = 0; i < 5; ++i)
-      values[i].value_ = i; 
+      values[i].value_ = i;
 
    typename unordered_multiset_type::bucket_type buckets [BucketSize];
    unordered_multiset_type testset(bucket_traits(
@@ -157,7 +157,7 @@
    testset.erase (testset.iterator_to (values[0]));
    testset.erase (testset.iterator_to (values[1]));
    testset.insert (values[1]);
-     
+    
    testset.erase (testset.iterator_to (values[2]));
    testset.erase (testset.iterator_to (values[3]));
 }
@@ -194,7 +194,7 @@
    }
    testset1.clear();
    BOOST_TEST (testset1.empty());
-}  
+} 
 
 //test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
@@ -231,7 +231,7 @@
 
          i = testset.insert (values[0]);
          BOOST_TEST (&*i == &values[0]);
-            
+           
          i = testset.iterator_to (values[2]);
          BOOST_TEST (&*i == &values[2]);
          testset.erase(i);
@@ -275,7 +275,7 @@
 
          i = testset.insert (values[0]);
          BOOST_TEST (&*i == &values[0]);
-            
+           
          i = testset.iterator_to (values[2]);
          BOOST_TEST (&*i == &values[2]);
          testset.erase(i);
@@ -317,7 +317,7 @@
       for(unsigned int i = 0, max = random_size; i != max; ++i){
          std::vector<typename ValueTraits::value_type> data (random_size);
          for (unsigned int j = 0; j < random_size; ++j)
-            data[j].value_ = random_init[j]; 
+            data[j].value_ = random_init[j];
          unordered_multiset_type testset_new(bucket_traits(
             pointer_traits<typename unordered_multiset_type::bucket_ptr>::
                pointer_to(single_bucket[0]), 1));
@@ -442,7 +442,7 @@
       //  BOOST_TEST (&testset1.front() == &values[3]);
       BOOST_TEST (&*testset1.begin() == &values[3]);
    }
-}  
+} 
 
 
 
@@ -651,7 +651,7 @@
    BOOST_TEST (testset1.size() == values.size());
    {  int init_values [] = { 1, 2, 2, 3, 4, 5 };
       TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() );  }
-}  
+} 
 
 //test: find, equal_range (lower_bound, upper_bound):
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
@@ -682,14 +682,14 @@
    BOOST_TEST (i->value_ == 2);
    BOOST_TEST ((++i)->value_ == 2);
    std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
-     
+    
    BOOST_TEST (range.first->value_ == 2);
    BOOST_TEST (range.second->value_ == 3);
    BOOST_TEST (std::distance (range.first, range.second) == 2);
 
    cmp_val.value_ = 7;
    BOOST_TEST (testset.find (cmp_val) == testset.end());
-} 
+}
 
 
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
@@ -781,7 +781,7 @@
       static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
       std::vector<testvalue<hooks<VoidPointer> , constant_time_size> > data (6);
       for (int i = 0; i < 6; ++i)
-         data[i].value_ = random_init[i]; 
+         data[i].value_ = random_init[i];
 
       test_unordered_multiset < typename detail::get_base_value_traits
                   < value_type
@@ -817,7 +817,7 @@
       static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
       std::vector<testvalue<hooks<VoidPointer> , false> > data (6);
       for (int i = 0; i < 6; ++i)
-         data[i].value_ = random_init[i]; 
+         data[i].value_ = random_init[i];
 
       test_unordered_multiset < typename detail::get_base_value_traits
                   < value_type
@@ -864,7 +864,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false, true>()();
    test_main_template<smart_ptr<void>, false, true>()();

Modified: trunk/libs/intrusive/test/unordered_set_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/unordered_set_test.cpp	(original)
+++ trunk/libs/intrusive/test/unordered_set_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -71,7 +71,7 @@
 static const std::size_t BucketSize = 8;
 
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
-struct test_unordered_set 
+struct test_unordered_set
 {
    typedef typename ValueTraits::value_type value_type;
    static void test_all(std::vector<value_type>& values);
@@ -142,7 +142,7 @@
 
    std::vector<value_type> values (5);
    for (int i = 0; i < 5; ++i)
-      values[i].value_ = i; 
+      values[i].value_ = i;
 
    typename unordered_set_type::bucket_type buckets [BucketSize];
    unordered_set_type testset(bucket_traits(
@@ -188,11 +188,11 @@
       {  int init_values [] = { 1, 2, 3, 4, 5 };
          TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() );  }
    }
-    
+   
    testset1.clear();
    BOOST_TEST (testset1.empty());
-}  
-  
+} 
+ 
 //test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
 void test_unordered_set<ValueTraits, CacheBegin, CompareHash, Incremental>::
@@ -251,7 +251,7 @@
       {  int init_values [] = { 1, 3, 5 };
          TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
    }
-}  
+} 
 
 //test: insert (seq-version), swap, erase (seq-version), size:
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
@@ -299,7 +299,7 @@
       BOOST_TEST (testset1.size() == 1);
       BOOST_TEST (&*testset1.begin() == &values[3]);
    }
-}  
+} 
 
 //test: rehash:
 template<class ValueTraits, bool CacheBegin, bool CompareHash, bool Incremental>
@@ -507,7 +507,7 @@
    BOOST_TEST (testset1.size() == values.size()-1);
    {  int init_values [] = { 1, 2, 3, 4, 5 };
       TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() );  }
-}  
+} 
 
 
 //test: find, equal_range (lower_bound, upper_bound):
@@ -538,7 +538,7 @@
    BOOST_TEST (i->value_ == 2);
    BOOST_TEST ((++i)->value_ != 2);
    std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
-     
+    
    BOOST_TEST (range.first->value_ == 2);
    BOOST_TEST (range.second->value_ == 3);
    BOOST_TEST (std::distance (range.first, range.second) == 1);
@@ -636,7 +636,7 @@
       static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
       std::vector<testvalue<hooks<VoidPointer> , constant_time_size> > data (6);
       for (int i = 0; i < 6; ++i)
-         data[i].value_ = random_init[i]; 
+         data[i].value_ = random_init[i];
 
       test_unordered_set < typename detail::get_base_value_traits
                   < value_type
@@ -672,7 +672,7 @@
       static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
       std::vector<testvalue<hooks<VoidPointer> , false> > data (6);
       for (int i = 0; i < 6; ++i)
-         data[i].value_ = random_init[i]; 
+         data[i].value_ = random_init[i];
 
       test_unordered_set < typename detail::get_base_value_traits
                   < value_type
@@ -719,7 +719,7 @@
    }
 };
 
-int main( int, char* [] ) 
+int main( int, char* [] )
 {
    test_main_template<void*, false, true>()();
    test_main_template<smart_ptr<void>, false, true>()();

Modified: trunk/libs/intrusive/test/virtual_base_test.cpp
==============================================================================
--- trunk/libs/intrusive/test/virtual_base_test.cpp	(original)
+++ trunk/libs/intrusive/test/virtual_base_test.cpp	2012-05-20 05:54:48 EDT (Sun, 20 May 2012)
@@ -78,7 +78,7 @@
 
       //Test the objects inserted in the base hook list
       for(; vect_it != vect_itend; ++vect_it, ++list_it)
-         if(&*list_it  != &*vect_it)   
+         if(&*list_it  != &*vect_it)  
             return 1;
    }