diff --git a/compatibility.htm b/compatibility.htm
new file mode 100644
index 0000000..d520bd1
--- /dev/null
+++ b/compatibility.htm
@@ -0,0 +1,88 @@
+
+
+
+ Smart Pointer Changes
+
+
+
+ 
Smart Pointer Changes
+ The February 2002 change to the Boost smart pointers introduced a number of
+ changes. Since the previous version of the smart pointers was in use for a long
+ time, it's useful to have a detailed list of what changed from a library user's
+ point of view.
+ Note that for compilers that don't support member templates well enough, a
+ separate implementation is used that lacks many of the new features and is more
+ like the old version.
+ Features Requiring Code Changes to Take Advantage
+
+ -
+ The smart pointer class templates now each have their own header file. For
+ compatibility, the <boost/smart_ptr.hpp>
+ header now includes the headers for the four classic smart pointer class
+ templates.
+
-
+ The weak_ptr
+ template was added.
+
-
+ The new shared_ptr and shared_array relax the requirement that
+ the pointed-to object's destructor must be visible when instantiating the shared_ptr
+ destructor. This makes it easier to have shared_ptr members in classes without
+ explicit destructors.
+
-
+ A custom deallocator can be passed in when creating a shared_ptr or shared_array.
+
-
+ shared_static_cast and shared_dynamic_cast function templates are
+ provided which work for shared_ptr and weak_ptr as static_cast
+ and dynamic_cast
+ do for pointers.
+
-
+ The self-assignment misfeature has been removed from shared_ptr::reset,
+ although it is still present in scoped_ptr, and in std::auto_ptr.
+ Calling reset with a pointer to the object that's already owned by the shared_ptr
+ results in undefined behavior (an assertion, or eventually a double-delete if
+ assertions are off).
+
-
+ The BOOST_SMART_PTR_CONVERSION
+ feature has been removed.
+
-
+ shared_ptr<void> is now allowed.
+
+ Features That Improve Robustness
+
+ -
+ The manipulation of use counts is now thread safe on
+ Windows, Linux, and platforms that support pthreads. See the
+ <boost/detail/atomic_count.hpp>
+ file for details
+
-
+ The new shared_ptr will always delete the object using the pointer it was
+ originally constructed with. This prevents subtle problems that could happen if
+ the last shared_ptr was a pointer to a sub-object of a class that did
+ not have a virtual destructor.
+
+ Implementation Details
+
+ -
+ Some bugs in the assignment operator implementations and in reset
+ have been fixed by using the "copy and swap" idiom.
+
-
+ Assertions have been added to check preconditions of various functions;
+ however, since these use the new <boost/assert.hpp>
+ header, the assertions are disabled by default.
+
-
+ The partial specialization of std::less has been replaced by operator<
+ overloads which accomplish the same thing without relying on undefined
+ behavior.
+
-
+ The incorrect overload of std::swap has been replaced by boost::swap,
+ which has many of the same advantages for generic programming but does not
+ violate the C++ standard.
+
+
+ Revised 1 February 2002
+ Copyright 2002 Darin Adler. 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.
+
+
diff --git a/enable_shared_from_this.html b/enable_shared_from_this.html
new file mode 100644
index 0000000..c4caa25
--- /dev/null
+++ b/enable_shared_from_this.html
@@ -0,0 +1,95 @@
+
+
+
+ Boost: enable_shared_from_this.hpp documentation
+
+
+
+
+
+ |
+ |
+
+ enable_shared_from_this.hpp
+ |
+
+
+ | |
+
+
+
+
+ The header <boost/enable_shared_from_this.hpp> defines
+ the class template enable_shared_from_this. It is used as a
+ base class that allows a shared_ptr to the current
+ object to be obtained from within a member function.
+
+ enable_shared_from_this<T> defines two member functions
+ called shared_from_this that return a shared_ptr<T>
+ and shared_ptr<T const>, depending on constness, to this.
+
+
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/shared_ptr.hpp>
+#include <cassert>
+
+class Y: public boost::enable_shared_from_this<Y>
+{
+public:
+
+ boost::shared_ptr<Y> f()
+ {
+ return shared_from_this();
+ }
+};
+
+int main()
+{
+ boost::shared_ptr<Y> p(new Y);
+ boost::shared_ptr<Y> q = p->f();
+ assert(p == q);
+ assert(!(p < q || q < p)); // p and q must share ownership
+}
+
+
+
+namespace boost
+{
+
+template<class T> class enable_shared_from_this
+{
+public:
+
+ shared_ptr<T> shared_from_this();
+ shared_ptr<T const> shared_from_this() const;
+}
+
+}
+
+ template<class T> shared_ptr<T>
+ enable_shared_from_this<T>::shared_from_this();
+ template<class T> shared_ptr<T const>
+ enable_shared_from_this<T>::shared_from_this() const;
+
+
+ Requires: enable_shared_from_this<T> must be an
+ accessible base class of T. *this must be a subobject
+ of an instance t of type T . There must exist
+ at least one shared_ptr instance p that owns
+ t.
+
+
+ Returns: A shared_ptr<T> instance r that shares
+ ownership with p.
+
+
+ Postconditions: r.get() == this.
+
+
+
+
+ Copyright © 2002, 2003 by Peter Dimov. 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.
+
+
diff --git a/example/scoped_ptr_example.cpp b/example/scoped_ptr_example.cpp
new file mode 100644
index 0000000..3dcfbb1
--- /dev/null
+++ b/example/scoped_ptr_example.cpp
@@ -0,0 +1,23 @@
+// Boost scoped_ptr_example implementation file -----------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "scoped_ptr_example.hpp"
+#include
+
+class example::implementation
+{
+ public:
+ ~implementation() { std::cout << "destroying implementation\n"; }
+};
+
+example::example() : _imp( new implementation ) {}
+
+void example::do_something() { std::cout << "did something\n"; }
+
+example::~example() {}
diff --git a/example/scoped_ptr_example.hpp b/example/scoped_ptr_example.hpp
new file mode 100644
index 0000000..0d9c603
--- /dev/null
+++ b/example/scoped_ptr_example.hpp
@@ -0,0 +1,29 @@
+// Boost scoped_ptr_example header file ------------------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include
+#include
+
+// The point of this example is to prove that even though
+// example::implementation is an incomplete type in translation units using
+// this header, scoped_ptr< implementation > is still valid because the type
+// is complete where it counts - in the inplementation translation unit where
+// destruction is actually instantiated.
+
+class example : private boost::noncopyable
+{
+ public:
+ example();
+ ~example();
+ void do_something();
+ private:
+ class implementation;
+ boost::scoped_ptr< implementation > _imp; // hide implementation details
+};
+
diff --git a/example/scoped_ptr_example_test.cpp b/example/scoped_ptr_example_test.cpp
new file mode 100644
index 0000000..26b3a18
--- /dev/null
+++ b/example/scoped_ptr_example_test.cpp
@@ -0,0 +1,17 @@
+// Boost scoped_ptr_example_test main program -------------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "scoped_ptr_example.hpp"
+
+int main()
+{
+ example my_example;
+ my_example.do_something();
+ return 0;
+}
diff --git a/example/shared_ptr_example.cpp b/example/shared_ptr_example.cpp
new file mode 100644
index 0000000..c3b1f3b
--- /dev/null
+++ b/example/shared_ptr_example.cpp
@@ -0,0 +1,95 @@
+// Boost shared_ptr_example.cpp --------------------------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+// Revision History
+// 21 May 01 Initial complete version (Beman Dawes)
+
+// The original code for this example appeared in the shared_ptr documentation.
+// Ray Gallimore pointed out that foo_set was missing a Compare template
+// argument, so would not work as intended. At that point the code was
+// turned into an actual .cpp file so it could be compiled and tested.
+
+#include
+#include
+#include
+#include
+#include
+
+// The application will produce a series of
+// objects of type Foo which later must be
+// accessed both by occurrence (std::vector)
+// and by ordering relationship (std::set).
+
+struct Foo
+{
+ Foo( int _x ) : x(_x) {}
+ ~Foo() { std::cout << "Destructing a Foo with x=" << x << "\n"; }
+ int x;
+ /* ... */
+};
+
+typedef boost::shared_ptr FooPtr;
+
+struct FooPtrOps
+{
+ bool operator()( const FooPtr & a, const FooPtr & b )
+ { return a->x > b->x; }
+ void operator()( const FooPtr & a )
+ { std::cout << a->x << "\n"; }
+};
+
+int main()
+{
+ std::vector foo_vector;
+ std::set foo_set; // NOT multiset!
+
+ FooPtr foo_ptr( new Foo( 2 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ foo_ptr.reset( new Foo( 1 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ foo_ptr.reset( new Foo( 3 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ foo_ptr.reset ( new Foo( 2 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ std::cout << "foo_vector:\n";
+ std::for_each( foo_vector.begin(), foo_vector.end(), FooPtrOps() );
+
+ std::cout << "\nfoo_set:\n";
+ std::for_each( foo_set.begin(), foo_set.end(), FooPtrOps() );
+ std::cout << "\n";
+
+// Expected output:
+//
+// foo_vector:
+// 2
+// 1
+// 3
+// 2
+//
+// foo_set:
+// 3
+// 2
+// 1
+//
+// Destructing a Foo with x=2
+// Destructing a Foo with x=1
+// Destructing a Foo with x=3
+// Destructing a Foo with x=2
+
+ return 0;
+}
+
diff --git a/example/shared_ptr_example2.cpp b/example/shared_ptr_example2.cpp
new file mode 100644
index 0000000..fdefc8d
--- /dev/null
+++ b/example/shared_ptr_example2.cpp
@@ -0,0 +1,22 @@
+// Boost shared_ptr_example2 implementation file -----------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "shared_ptr_example2.hpp"
+#include
+
+class example::implementation
+{
+ public:
+ ~implementation() { std::cout << "destroying implementation\n"; }
+};
+
+example::example() : _imp( new implementation ) {}
+
+void example::do_something()
+ { std::cout << "use_count() is " << _imp.use_count() << "\n"; }
diff --git a/example/shared_ptr_example2.hpp b/example/shared_ptr_example2.hpp
new file mode 100644
index 0000000..5ca7a07
--- /dev/null
+++ b/example/shared_ptr_example2.hpp
@@ -0,0 +1,31 @@
+// Boost shared_ptr_example2 header file -----------------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include
+
+// This example demonstrates the handle/body idiom (also called pimpl and
+// several other names). It separates the interface (in this header file)
+// from the implementation (in shared_ptr_example2.cpp).
+
+// Note that even though example::implementation is an incomplete type in
+// some translation units using this header, shared_ptr< implementation >
+// is still valid because the type is complete where it counts - in the
+// shared_ptr_example2.cpp translation unit where functions requiring a
+// complete type are actually instantiated.
+
+class example
+{
+public:
+ example();
+ void do_something();
+private:
+ class implementation;
+ boost::shared_ptr< implementation > _imp; // hide implementation details
+};
+
diff --git a/example/shared_ptr_example2_test.cpp b/example/shared_ptr_example2_test.cpp
new file mode 100644
index 0000000..2702cb8
--- /dev/null
+++ b/example/shared_ptr_example2_test.cpp
@@ -0,0 +1,22 @@
+// Boost shared_ptr_example2_test main program ------------------------------//
+
+// Copyright Beman Dawes 2001. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "shared_ptr_example2.hpp"
+
+int main()
+{
+ example a;
+ a.do_something();
+ example b(a);
+ b.do_something();
+ example c;
+ c = a;
+ c.do_something();
+ return 0;
+}
diff --git a/gccspeed.gif b/gccspeed.gif
new file mode 100644
index 0000000..d78c06b
Binary files /dev/null and b/gccspeed.gif differ
diff --git a/include/boost/detail/atomic_count.hpp b/include/boost/detail/atomic_count.hpp
new file mode 100644
index 0000000..5411c7a
--- /dev/null
+++ b/include/boost/detail/atomic_count.hpp
@@ -0,0 +1,21 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/atomic_count.hpp - thread/SMP safe reference counter
+//
+// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//
+// 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
+
+#include
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
diff --git a/include/boost/detail/lightweight_mutex.hpp b/include/boost/detail/lightweight_mutex.hpp
new file mode 100644
index 0000000..b7a7f6d
--- /dev/null
+++ b/include/boost/detail/lightweight_mutex.hpp
@@ -0,0 +1,22 @@
+#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+#define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/lightweight_mutex.hpp - lightweight mutex
+//
+// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+// 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
+//
+
+#include
+
+#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
diff --git a/include/boost/detail/sp_typeinfo.hpp b/include/boost/detail/sp_typeinfo.hpp
new file mode 100644
index 0000000..43fae78
--- /dev/null
+++ b/include/boost/detail/sp_typeinfo.hpp
@@ -0,0 +1,135 @@
+#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// detail/sp_typeinfo.hpp
+//
+// Copyright 2007 Peter Dimov
+//
+// 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)
+
+#include
+
+#if defined( BOOST_NO_TYPEID )
+
+#include
+#include
+
+namespace boost
+{
+
+namespace detail
+{
+
+class sp_typeinfo
+{
+private:
+
+ sp_typeinfo( sp_typeinfo const& );
+ sp_typeinfo& operator=( sp_typeinfo const& );
+
+ char const * name_;
+
+public:
+
+ explicit sp_typeinfo( char const * name ): name_( name )
+ {
+ }
+
+ bool operator==( sp_typeinfo const& rhs ) const
+ {
+ return this == &rhs;
+ }
+
+ bool operator!=( sp_typeinfo const& rhs ) const
+ {
+ return this != &rhs;
+ }
+
+ bool before( sp_typeinfo const& rhs ) const
+ {
+ return std::less< sp_typeinfo const* >()( this, &rhs );
+ }
+
+ char const* name() const
+ {
+ return name_;
+ }
+};
+
+template struct sp_typeid_
+{
+ static sp_typeinfo ti_;
+
+ static char const * name()
+ {
+ return BOOST_CURRENT_FUNCTION;
+ }
+};
+
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization
+// constructor arguments. But an assignment works just fine.
+template sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
+#else
+template sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name());
+#endif
+
+template struct sp_typeid_< T & >: sp_typeid_< T >
+{
+};
+
+template struct sp_typeid_< T const >: sp_typeid_< T >
+{
+};
+
+template struct sp_typeid_< T volatile >: sp_typeid_< T >
+{
+};
+
+template struct sp_typeid_< T const volatile >: sp_typeid_< T >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID(T) (boost::detail::sp_typeid_::ti_)
+
+#else
+
+#include
+
+namespace boost
+{
+
+namespace detail
+{
+
+#if defined( BOOST_NO_STD_TYPEINFO )
+
+typedef ::type_info sp_typeinfo;
+
+#else
+
+typedef std::type_info sp_typeinfo;
+
+#endif
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID(T) typeid(T)
+
+#endif
+
+#endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
diff --git a/include/boost/enable_shared_from_this.hpp b/include/boost/enable_shared_from_this.hpp
new file mode 100644
index 0000000..b1bb63d
--- /dev/null
+++ b/include/boost/enable_shared_from_this.hpp
@@ -0,0 +1,18 @@
+#ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
+//
+// enable_shared_from_this.hpp
+//
+// Copyright (c) 2002 Peter Dimov
+//
+// 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
+//
+// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//
+
+#include
+
+#endif // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
diff --git a/include/boost/get_pointer.hpp b/include/boost/get_pointer.hpp
new file mode 100644
index 0000000..b27b98a
--- /dev/null
+++ b/include/boost/get_pointer.hpp
@@ -0,0 +1,48 @@
+// Copyright Peter Dimov and David Abrahams 2002.
+// 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)
+#ifndef GET_POINTER_DWA20021219_HPP
+#define GET_POINTER_DWA20021219_HPP
+
+#include
+
+// In order to avoid circular dependencies with Boost.TR1
+// we make sure that our include of doesn't try to
+// pull in the TR1 headers: that's why we use this header
+// rather than including directly:
+#include // std::auto_ptr
+
+namespace boost {
+
+// get_pointer(p) extracts a ->* capable pointer from p
+
+template T * get_pointer(T * p)
+{
+ return p;
+}
+
+// get_pointer(shared_ptr const & p) has been moved to shared_ptr.hpp
+
+template T * get_pointer(std::auto_ptr const& p)
+{
+ return p.get();
+}
+
+#if !defined( BOOST_NO_CXX11_SMART_PTR )
+
+template T * get_pointer( std::unique_ptr const& p )
+{
+ return p.get();
+}
+
+template T * get_pointer( std::shared_ptr const& p )
+{
+ return p.get();
+}
+
+#endif
+
+} // namespace boost
+
+#endif // GET_POINTER_DWA20021219_HPP
diff --git a/include/boost/intrusive_ptr.hpp b/include/boost/intrusive_ptr.hpp
new file mode 100644
index 0000000..63036dc
--- /dev/null
+++ b/include/boost/intrusive_ptr.hpp
@@ -0,0 +1,18 @@
+#ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
+#define BOOST_INTRUSIVE_PTR_HPP_INCLUDED
+
+//
+// intrusive_ptr.hpp
+//
+// Copyright (c) 2001, 2002 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
+//
+
+#include
+
+#endif // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
diff --git a/include/boost/make_shared.hpp b/include/boost/make_shared.hpp
new file mode 100644
index 0000000..c04938f
--- /dev/null
+++ b/include/boost/make_shared.hpp
@@ -0,0 +1,17 @@
+#ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
+#define BOOST_MAKE_SHARED_HPP_INCLUDED
+
+// make_shared.hpp
+//
+// Copyright (c) 2007, 2008 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See http://www.boost.org/libs/smart_ptr/make_shared.html
+// for documentation.
+
+#include
+
+#endif // #ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
diff --git a/include/boost/memory_order.hpp b/include/boost/memory_order.hpp
new file mode 100644
index 0000000..4945af6
--- /dev/null
+++ b/include/boost/memory_order.hpp
@@ -0,0 +1,53 @@
+#ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
+#define BOOST_MEMORY_ORDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/memory_order.hpp
+//
+// Defines enum boost::memory_order per the C++0x working draft
+//
+// Copyright (c) 2008, 2009 Peter Dimov
+//
+// 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)
+
+
+namespace boost
+{
+
+//
+// Enum values are chosen so that code that needs to insert
+// a trailing fence for acquire semantics can use a single
+// test such as:
+//
+// if( mo & memory_order_acquire ) { ...fence... }
+//
+// For leading fences one can use:
+//
+// if( mo & memory_order_release ) { ...fence... }
+//
+// Architectures such as Alpha that need a fence on consume
+// can use:
+//
+// if( mo & ( memory_order_acquire | memory_order_consume ) ) { ...fence... }
+//
+
+enum memory_order
+{
+ memory_order_relaxed = 0,
+ memory_order_acquire = 1,
+ memory_order_release = 2,
+ memory_order_acq_rel = 3, // acquire | release
+ memory_order_seq_cst = 7, // acq_rel | 4
+ memory_order_consume = 8
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
diff --git a/include/boost/pointer_cast.hpp b/include/boost/pointer_cast.hpp
new file mode 100644
index 0000000..6e532eb
--- /dev/null
+++ b/include/boost/pointer_cast.hpp
@@ -0,0 +1,45 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005.
+// 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)
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_POINTER_CAST_HPP
+#define BOOST_POINTER_CAST_HPP
+
+namespace boost {
+
+//static_pointer_cast overload for raw pointers
+template
+inline T* static_pointer_cast(U *ptr)
+{
+ return static_cast(ptr);
+}
+
+//dynamic_pointer_cast overload for raw pointers
+template
+inline T* dynamic_pointer_cast(U *ptr)
+{
+ return dynamic_cast(ptr);
+}
+
+//const_pointer_cast overload for raw pointers
+template
+inline T* const_pointer_cast(U *ptr)
+{
+ return const_cast(ptr);
+}
+
+//reinterpret_pointer_cast overload for raw pointers
+template
+inline T* reinterpret_pointer_cast(U *ptr)
+{
+ return reinterpret_cast(ptr);
+}
+
+} // namespace boost
+
+#endif //BOOST_POINTER_CAST_HPP
diff --git a/include/boost/pointer_to_other.hpp b/include/boost/pointer_to_other.hpp
new file mode 100644
index 0000000..8516734
--- /dev/null
+++ b/include/boost/pointer_to_other.hpp
@@ -0,0 +1,55 @@
+#ifndef BOOST_POINTER_TO_OTHER_HPP_INCLUDED
+#define BOOST_POINTER_TO_OTHER_HPP_INCLUDED
+
+//
+// pointer_to_other.hpp
+//
+// (C) Copyright Ion Gaztanaga 2005.
+// Copyright (c) 2005 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/smart_ptr/pointer_to_other.html
+//
+
+namespace boost
+{
+
+// Defines the same pointer type (raw or smart) to another pointee type
+
+template
+struct pointer_to_other;
+
+template class Sp>
+struct pointer_to_other< Sp, U >
+{
+ typedef Sp type;
+};
+
+template class Sp>
+struct pointer_to_other< Sp, U >
+{
+ typedef Sp type;
+};
+
+template class Sp>
+struct pointer_to_other< Sp, U >
+{
+ typedef Sp type;
+};
+
+template
+struct pointer_to_other< T*, U >
+{
+ typedef U* type;
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_POINTER_TO_OTHER_HPP_INCLUDED
diff --git a/include/boost/scoped_array.hpp b/include/boost/scoped_array.hpp
new file mode 100644
index 0000000..c02fa31
--- /dev/null
+++ b/include/boost/scoped_array.hpp
@@ -0,0 +1,16 @@
+#ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
+#define BOOST_SCOPED_ARRAY_HPP_INCLUDED
+
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001, 2002 Peter Dimov
+//
+// 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)
+//
+// http://www.boost.org/libs/smart_ptr/scoped_array.htm
+//
+
+#include
+
+#endif // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
diff --git a/include/boost/scoped_ptr.hpp b/include/boost/scoped_ptr.hpp
new file mode 100644
index 0000000..cb916da
--- /dev/null
+++ b/include/boost/scoped_ptr.hpp
@@ -0,0 +1,16 @@
+#ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
+#define BOOST_SCOPED_PTR_HPP_INCLUDED
+
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001, 2002 Peter Dimov
+//
+// 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)
+//
+// http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
+//
+
+#include
+
+#endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
diff --git a/include/boost/shared_array.hpp b/include/boost/shared_array.hpp
new file mode 100644
index 0000000..0700ce4
--- /dev/null
+++ b/include/boost/shared_array.hpp
@@ -0,0 +1,19 @@
+#ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
+#define BOOST_SHARED_ARRAY_HPP_INCLUDED
+
+//
+// shared_array.hpp
+//
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001, 2002 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
+//
+
+#include
+
+#endif // #ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
diff --git a/include/boost/shared_ptr.hpp b/include/boost/shared_ptr.hpp
new file mode 100644
index 0000000..d31978c
--- /dev/null
+++ b/include/boost/shared_ptr.hpp
@@ -0,0 +1,19 @@
+#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SHARED_PTR_HPP_INCLUDED
+
+//
+// shared_ptr.hpp
+//
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001-2008 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include
+
+#endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
diff --git a/include/boost/smart_ptr.hpp b/include/boost/smart_ptr.hpp
new file mode 100644
index 0000000..b5e569d
--- /dev/null
+++ b/include/boost/smart_ptr.hpp
@@ -0,0 +1,31 @@
+#ifndef BOOST_SMART_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_HPP_INCLUDED
+
+//
+// smart_ptr.hpp
+//
+// For convenience, this header includes the rest of the smart
+// pointer library headers.
+//
+// Copyright (c) 2003 Peter Dimov 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)
+//
+// http://www.boost.org/libs/smart_ptr/smart_ptr.htm
+//
+
+#include
+
+#include
+#include
+#include
+#include
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+# include
+# include
+# include
+# include
+#endif
+
+#endif // #ifndef BOOST_SMART_PTR_HPP_INCLUDED
diff --git a/include/boost/smart_ptr/allocate_shared_array.hpp b/include/boost/smart_ptr/allocate_shared_array.hpp
new file mode 100644
index 0000000..3ee1655
--- /dev/null
+++ b/include/boost/smart_ptr/allocate_shared_array.hpp
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2012 Glen Joseph Fernandes
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
+
+#include
+#include
+#include
+#include
+#include
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include
+#endif
+
+namespace boost {
+ template
+ inline typename boost::detail::sp_if_array::type
+ allocate_shared(const A& allocator, std::size_t size) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ T1* p1 = 0;
+ T2* p2 = 0;
+ std::size_t n1 = size * boost::detail::array_total::size;
+ boost::detail::allocate_array_helper a1(allocator, n1, &p2);
+ boost::detail::array_deleter d1(n1);
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init(p2);
+ return boost::shared_ptr(s1, p1);
+ }
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ template
+ inline typename boost::detail::sp_if_array::type
+ allocate_shared(const A& allocator, std::size_t size, Args&&... args) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ T1* p1 = 0;
+ T2* p2 = 0;
+ std::size_t n1 = size * boost::detail::array_total::size;
+ boost::detail::allocate_array_helper a1(allocator, n1, &p2);
+ boost::detail::array_deleter d1(n1);
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init(p2, boost::detail::sp_forward(args)...);
+ return boost::shared_ptr(s1, p1);
+ }
+ template
+ inline typename boost::detail::sp_if_size_array::type
+ allocate_shared(const A& allocator, Args&&... args) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ enum {
+ N = boost::detail::array_total::size
+ };
+ T1* p1 = 0;
+ T2* p2 = 0;
+ boost::detail::allocate_array_helper a1(allocator, &p2);
+ boost::detail::array_deleter d1;
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init(p2, boost::detail::sp_forward(args)...);
+ return boost::shared_ptr(s1, p1);
+ }
+#endif
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
+ template
+ inline typename boost::detail::sp_if_size_array::type
+ allocate_shared(const A& allocator, const T& list) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ typedef const T2 T3;
+ enum {
+ N = boost::detail::array_total::size
+ };
+ T1* p1 = 0;
+ T2* p2 = 0;
+ T3* p3 = 0;
+ boost::detail::allocate_array_helper a1(allocator, &p2);
+ boost::detail::array_deleter d1;
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p3 = reinterpret_cast(list);
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init_list(p2, p3);
+ return boost::shared_ptr(s1, p1);
+ }
+ template
+ inline typename boost::detail::sp_if_array::type
+ allocate_shared(const A& allocator, std::size_t size,
+ const typename boost::detail::array_inner::type& list) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ typedef const T2 T3;
+ enum {
+ M = boost::detail::array_total::size
+ };
+ T1* p1 = 0;
+ T2* p2 = 0;
+ T3* p3 = 0;
+ std::size_t n1 = M * size;
+ boost::detail::allocate_array_helper a1(allocator, n1, &p2);
+ boost::detail::array_deleter d1(n1);
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p3 = reinterpret_cast(list);
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->template init_list(p2, p3);
+ return boost::shared_ptr(s1, p1);
+ }
+ template
+ inline typename boost::detail::sp_if_size_array::type
+ allocate_shared(const A& allocator,
+ const typename boost::detail::array_inner::type& list) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ typedef const T2 T3;
+ enum {
+ M = boost::detail::array_total::size,
+ N = boost::detail::array_total::size
+ };
+ T1* p1 = 0;
+ T2* p2 = 0;
+ T3* p3 = 0;
+ boost::detail::allocate_array_helper a1(allocator, &p2);
+ boost::detail::array_deleter d1;
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p3 = reinterpret_cast(list);
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->template init_list(p2, p3);
+ return boost::shared_ptr(s1, p1);
+ }
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+ template
+ inline typename boost::detail::sp_if_array::type
+ allocate_shared(const A& allocator,
+ std::initializer_list::type> list) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ typedef const T2 T3;
+ T1* p1 = 0;
+ T2* p2 = 0;
+ T3* p3 = 0;
+ std::size_t n1 = list.size() * boost::detail::array_total::size;
+ boost::detail::allocate_array_helper a1(allocator, n1, &p2);
+ boost::detail::array_deleter d1(n1);
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p3 = reinterpret_cast(list.begin());
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init_list(p2, p3);
+ return boost::shared_ptr(s1, p1);
+ }
+#endif
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ template
+ inline typename boost::detail::sp_if_array::type
+ allocate_shared(const A& allocator, std::size_t size,
+ typename boost::detail::array_base::type&& value) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ T1* p1 = 0;
+ T2* p2 = 0;
+ std::size_t n1 = size * boost::detail::array_total::size;
+ boost::detail::allocate_array_helper a1(allocator, n1, &p2);
+ boost::detail::array_deleter d1(n1);
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init(p2, boost::detail::sp_forward(value));
+ return boost::shared_ptr(s1, p1);
+ }
+ template
+ inline typename boost::detail::sp_if_size_array::type
+ allocate_shared(const A& allocator,
+ typename boost::detail::array_base::type&& value) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ enum {
+ N = boost::detail::array_total::size
+ };
+ T1* p1 = 0;
+ T2* p2 = 0;
+ boost::detail::allocate_array_helper a1(allocator, &p2);
+ boost::detail::array_deleter d1;
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->init(p2, boost::detail::sp_forward(value));
+ return boost::shared_ptr(s1, p1);
+ }
+#endif
+#endif
+ template
+ inline typename boost::detail::sp_if_array::type
+ allocate_shared_noinit(const A& allocator, std::size_t size) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ T1* p1 = 0;
+ T2* p2 = 0;
+ std::size_t n1 = size * boost::detail::array_total::size;
+ boost::detail::allocate_array_helper a1(allocator, n1, &p2);
+ boost::detail::array_deleter d1(n1);
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->noinit(p2);
+ return boost::shared_ptr(s1, p1);
+ }
+ template
+ inline typename boost::detail::sp_if_size_array::type
+ allocate_shared_noinit(const A& allocator) {
+ typedef typename boost::detail::array_inner::type T1;
+ typedef typename boost::detail::array_base::type T2;
+ enum {
+ N = boost::detail::array_total::size
+ };
+ T1* p1 = 0;
+ T2* p2 = 0;
+ boost::detail::allocate_array_helper a1(allocator, &p2);
+ boost::detail::array_deleter d1;
+ boost::shared_ptr s1(p1, d1, a1);
+ typedef boost::detail::array_deleter* D2;
+ p1 = reinterpret_cast(p2);
+ D2 d2 = static_cast(s1._internal_get_untyped_deleter());
+ d2->noinit(p2);
+ return boost::shared_ptr(s1, p1);
+ }
+}
+
+#endif
diff --git a/include/boost/smart_ptr/bad_weak_ptr.hpp b/include/boost/smart_ptr/bad_weak_ptr.hpp
new file mode 100644
index 0000000..3e0a1b7
--- /dev/null
+++ b/include/boost/smart_ptr/bad_weak_ptr.hpp
@@ -0,0 +1,59 @@
+#ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/smart_ptr/bad_weak_ptr.hpp
+//
+// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+// 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)
+//
+
+#include
+
+#ifdef __BORLANDC__
+# pragma warn -8026 // Functions with excep. spec. are not expanded inline
+#endif
+
+namespace boost
+{
+
+// The standard library that comes with Borland C++ 5.5.1, 5.6.4
+// defines std::exception and its members as having C calling
+// convention (-pc). When the definition of bad_weak_ptr
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below.
+
+#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
+# pragma option push -pc
+#endif
+
+class bad_weak_ptr: public std::exception
+{
+public:
+
+ virtual char const * what() const throw()
+ {
+ return "tr1::bad_weak_ptr";
+ }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
+# pragma option pop
+#endif
+
+} // namespace boost
+
+#ifdef __BORLANDC__
+# pragma warn .8026 // Functions with excep. spec. are not expanded inline
+#endif
+
+#endif // #ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
diff --git a/include/boost/smart_ptr/detail/allocate_array_helper.hpp b/include/boost/smart_ptr/detail/allocate_array_helper.hpp
new file mode 100644
index 0000000..2eeea2d
--- /dev/null
+++ b/include/boost/smart_ptr/detail/allocate_array_helper.hpp
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2012 Glen Joseph Fernandes
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_SMART_PTR_DETAIL_ALLOCATE_ARRAY_HELPER_HPP
+#define BOOST_SMART_PTR_DETAIL_ALLOCATE_ARRAY_HELPER_HPP
+
+#include
+
+namespace boost {
+ namespace detail {
+ template
+ class allocate_array_helper;
+ template
+ class allocate_array_helper {
+ template
+ friend class allocate_array_helper;
+ typedef typename A::template rebind ::other A2;
+ typedef typename A::template rebind::other A3;
+ public:
+ typedef typename A2::value_type value_type;
+ typedef typename A2::pointer pointer;
+ typedef typename A2::const_pointer const_pointer;
+ typedef typename A2::reference reference;
+ typedef typename A2::const_reference const_reference;
+ typedef typename A2::size_type size_type;
+ typedef typename A2::difference_type difference_type;
+ template
+ struct rebind {
+ typedef allocate_array_helper other;
+ };
+ allocate_array_helper(const A& allocator_, std::size_t size_, T** data_)
+ : allocator(allocator_),
+ size(sizeof(T) * size_),
+ data(data_) {
+ }
+ template
+ allocate_array_helper(const allocate_array_helper& other)
+ : allocator(other.allocator),
+ size(other.size),
+ data(other.data) {
+ }
+ pointer address(reference value) const {
+ return allocator.address(value);
+ }
+ const_pointer address(const_reference value) const {
+ return allocator.address(value);
+ }
+ size_type max_size() const {
+ return allocator.max_size();
+ }
+ pointer allocate(size_type count, const void* value = 0) {
+ std::size_t a1 = boost::alignment_of::value;
+ std::size_t n1 = count * sizeof(Y) + a1 - 1;
+ char* p1 = A3(allocator).allocate(n1 + size, value);
+ char* p2 = p1 + n1;
+ while (std::size_t(p2) % a1 != 0) {
+ p2--;
+ }
+ *data = reinterpret_cast(p2);
+ return reinterpret_cast(p1);
+ }
+ void deallocate(pointer memory, size_type count) {
+ std::size_t a1 = boost::alignment_of::value;
+ std::size_t n1 = count * sizeof(Y) + a1 - 1;
+ char* p1 = reinterpret_cast(memory);
+ A3(allocator).deallocate(p1, n1 + size);
+ }
+ void construct(pointer memory, const Y& value) {
+ allocator.construct(memory, value);
+ }
+ void destroy(pointer memory) {
+ allocator.destroy(memory);
+ }
+ template
+ bool operator==(const allocate_array_helper& other) const {
+ return allocator == other.allocator;
+ }
+ template
+ bool operator!=(const allocate_array_helper& other) const {
+ return !(*this == other);
+ }
+ private:
+ A2 allocator;
+ std::size_t size;
+ T** data;
+ };
+ template
+ class allocate_array_helper {
+ template
+ friend class allocate_array_helper;
+ typedef typename A::template rebind