Updated to r8541

boost/boost/circular_buffer.hpp

@@ -0,0 +1,62 @@
+// Circular buffer library header file.
+
+// Copyright (c) 2003-2008 Jan Gaspar
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See www.boost.org/libs/circular_buffer for documentation.
+
+#if !defined(BOOST_CIRCULAR_BUFFER_HPP)
+#define BOOST_CIRCULAR_BUFFER_HPP
+
+#if defined(_MSC_VER)
+    #pragma once
+#endif
+
+#include <boost/circular_buffer_fwd.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+
+// BOOST_CB_ENABLE_DEBUG: Debug support control.
+#if !defined(BOOST_CB_ENABLE_DEBUG)
+    #define BOOST_CB_ENABLE_DEBUG 0
+#endif
+
+// BOOST_CB_ASSERT: Runtime assertion.
+#if BOOST_CB_ENABLE_DEBUG
+    #include <boost/assert.hpp>
+    #define BOOST_CB_ASSERT(Expr) BOOST_ASSERT(Expr)
+#else
+    #define BOOST_CB_ASSERT(Expr) ((void)0)
+#endif
+
+// BOOST_CB_IS_CONVERTIBLE: Check if Iterator::value_type is convertible to Type.
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+    #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) ((void)0)
+#else
+    #include <boost/detail/iterator.hpp>
+    #include <boost/type_traits/is_convertible.hpp>
+    #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) \
+        BOOST_STATIC_ASSERT((is_convertible<typename detail::iterator_traits<Iterator>::value_type, Type>::value))
+#endif
+
+// BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS:
+// Check if the STL provides templated iterator constructors for its containers.
+#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
+    #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS BOOST_STATIC_ASSERT(false);
+#else
+    #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS ((void)0);
+#endif
+
+#include <boost/circular_buffer/debug.hpp>
+#include <boost/circular_buffer/details.hpp>
+#include <boost/circular_buffer/base.hpp>
+#include <boost/circular_buffer/space_optimized.hpp>
+
+#undef BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS
+#undef BOOST_CB_IS_CONVERTIBLE
+#undef BOOST_CB_ASSERT
+
+#endif // #if !defined(BOOST_CIRCULAR_BUFFER_HPP)

boost/boost/circular_buffer/debug.hpp

@@ -0,0 +1,248 @@
+// Debug support for the circular buffer library.
+
+// Copyright (c) 2003-2008 Jan Gaspar
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_CIRCULAR_BUFFER_DEBUG_HPP)
+#define BOOST_CIRCULAR_BUFFER_DEBUG_HPP
+
+#if defined(_MSC_VER)
+    #pragma once
+#endif
+
+#if BOOST_CB_ENABLE_DEBUG
+#include <cstring>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std {
+    using ::memset;
+}
+#endif
+
+#endif // BOOST_CB_ENABLE_DEBUG
+namespace boost {
+
+namespace cb_details {
+
+#if BOOST_CB_ENABLE_DEBUG
+
+// The value the uninitialized memory is filled with.
+const int UNINITIALIZED = 0xcc;
+
+template <class T>
+inline void do_fill_uninitialized_memory(T* data, std::size_t size_in_bytes) BOOST_NOEXCEPT {
+    std::memset(static_cast<void*>(data), UNINITIALIZED, size_in_bytes);
+}
+
+template <class T>
+inline void do_fill_uninitialized_memory(T& /*data*/, std::size_t /*size_in_bytes*/) BOOST_NOEXCEPT {
+    // Do nothing
+}
+
+
+class debug_iterator_registry;
+
+/*!
+    \class debug_iterator_base
+    \brief Registers/unregisters iterators into the registry of valid iterators.
+
+    This class is intended to be a base class of an iterator.
+*/
+class debug_iterator_base {
+
+private:
+// Members
+
+    //! Iterator registry.
+    mutable const debug_iterator_registry* m_registry;
+
+    //! Next iterator in the iterator chain.
+    mutable const debug_iterator_base* m_next;
+
+public:
+// Construction/destruction
+
+    //! Default constructor.
+    debug_iterator_base();
+
+    //! Constructor taking the iterator registry as a parameter.
+    debug_iterator_base(const debug_iterator_registry* registry);
+
+    //! Copy constructor.
+    debug_iterator_base(const debug_iterator_base& rhs);
+
+    //! Destructor.
+    ~debug_iterator_base();
+
+// Methods
+
+    //! Assign operator.
+    debug_iterator_base& operator = (const debug_iterator_base& rhs);
+
+    //! Is the iterator valid?
+    bool is_valid(const debug_iterator_registry* registry) const;
+
+    //! Invalidate the iterator.
+    /*!
+        \note The method is const in order to invalidate const iterators, too.
+    */
+    void invalidate() const;
+
+    //! Return the next iterator in the iterator chain.
+    const debug_iterator_base* next() const;
+
+    //! Set the next iterator in the iterator chain.
+    /*!
+        \note The method is const in order to set a next iterator to a const iterator, too.
+    */
+    void set_next(const debug_iterator_base* it) const;
+
+private:
+// Helpers
+
+    //! Register self as a valid iterator.
+    void register_self();
+
+    //! Unregister self from valid iterators.
+    void unregister_self();
+};
+
+/*!
+    \class debug_iterator_registry
+    \brief Registry of valid iterators.
+
+    This class is intended to be a base class of a container.
+*/
+class debug_iterator_registry {
+
+    //! Pointer to the chain of valid iterators.
+    mutable const debug_iterator_base* m_iterators;
+
+public:
+// Methods
+
+    //! Default constructor.
+    debug_iterator_registry() : m_iterators(0) {}
+
+    //! Register an iterator into the list of valid iterators.
+    /*!
+        \note The method is const in order to register iterators into const containers, too.
+    */
+    void register_iterator(const debug_iterator_base* it) const {
+        it->set_next(m_iterators);
+        m_iterators = it;
+    }
+
+    //! Unregister an iterator from the list of valid iterators.
+    /*!
+        \note The method is const in order to unregister iterators from const containers, too.
+    */
+    void unregister_iterator(const debug_iterator_base* it) const {
+        const debug_iterator_base* previous = 0;
+        for (const debug_iterator_base* p = m_iterators; p != it; previous = p, p = p->next()) {}
+        remove(it, previous);
+    }
+
+    //! Invalidate every iterator pointing to the same element as the iterator passed as a parameter.
+    template <class Iterator>
+    void invalidate_iterators(const Iterator& it) {
+        const debug_iterator_base* previous = 0;
+        for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) {
+            if (((Iterator*)p)->m_it == it.m_it) {
+                p->invalidate();
+                remove(p, previous);
+                continue;
+            }
+            previous = p;
+        }
+    }
+
+    //! Invalidate all iterators except an iterator poining to the same element as the iterator passed as a parameter.
+    template <class Iterator>
+    void invalidate_iterators_except(const Iterator& it) {
+        const debug_iterator_base* previous = 0;
+        for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) {
+            if (((Iterator*)p)->m_it != it.m_it) {
+                p->invalidate();
+                remove(p, previous);
+                continue;
+            }
+            previous = p;
+        }
+    }
+
+    //! Invalidate all iterators.
+    void invalidate_all_iterators() {
+        for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next())
+            p->invalidate();
+        m_iterators = 0;
+    }
+
+private:
+// Helpers
+
+    //! Remove the current iterator from the iterator chain.
+    void remove(const debug_iterator_base* current,
+                const debug_iterator_base* previous) const {
+        if (previous == 0)
+            m_iterators = m_iterators->next();
+        else
+            previous->set_next(current->next());
+    }
+};
+
+// Implementation of the debug_iterator_base methods.
+
+inline debug_iterator_base::debug_iterator_base() : m_registry(0), m_next(0) {}
+
+inline debug_iterator_base::debug_iterator_base(const debug_iterator_registry* registry)
+: m_registry(registry), m_next(0) {
+    register_self();
+}
+
+inline debug_iterator_base::debug_iterator_base(const debug_iterator_base& rhs)
+: m_registry(rhs.m_registry), m_next(0) {
+    register_self();
+}
+
+inline debug_iterator_base::~debug_iterator_base() { unregister_self(); }
+
+inline debug_iterator_base& debug_iterator_base::operator = (const debug_iterator_base& rhs) {
+    if (m_registry == rhs.m_registry)
+        return *this;
+    unregister_self();
+    m_registry = rhs.m_registry;
+    register_self();
+    return *this;
+}
+
+inline bool debug_iterator_base::is_valid(const debug_iterator_registry* registry) const {
+    return m_registry == registry;
+}
+
+inline void debug_iterator_base::invalidate() const { m_registry = 0; }
+
+inline const debug_iterator_base* debug_iterator_base::next() const { return m_next; }
+
+inline void debug_iterator_base::set_next(const debug_iterator_base* it) const { m_next = it; }
+
+inline void debug_iterator_base::register_self() {
+    if (m_registry != 0)
+        m_registry->register_iterator(this);
+}
+
+inline void debug_iterator_base::unregister_self() {
+    if (m_registry != 0)
+        m_registry->unregister_iterator(this);
+}
+
+#endif // #if BOOST_CB_ENABLE_DEBUG
+
+} // namespace cb_details
+
+} // namespace boost
+
+#endif // #if !defined(BOOST_CIRCULAR_BUFFER_DEBUG_HPP)

boost/boost/circular_buffer/details.hpp

@@ -0,0 +1,498 @@
+// Helper classes and functions for the circular buffer.
+
+// Copyright (c) 2003-2008 Jan Gaspar
+// Copyright (c) 2014 Glen Fernandes   // C++11 allocator model support.
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_CIRCULAR_BUFFER_DETAILS_HPP)
+#define BOOST_CIRCULAR_BUFFER_DETAILS_HPP
+
+#if defined(_MSC_VER)
+    #pragma once
+#endif
+
+#include <boost/throw_exception.hpp>
+#include <boost/container/allocator_traits.hpp>
+#include <boost/move/move.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <iterator>
+
+// Silence MS /W4 warnings like C4913:
+// "user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used"
+// This might happen when previously including some boost headers that overload the coma operator.
+#if defined(_MSC_VER)
+#  pragma warning(push)
+#  pragma warning(disable:4913)
+#endif
+
+namespace boost {
+
+namespace cb_details {
+
+template <class Traits> struct nonconst_traits;
+
+template<class ForwardIterator, class Diff, class T, class Alloc>
+void uninitialized_fill_n_with_alloc(
+    ForwardIterator first, Diff n, const T& item, Alloc& alloc);
+
+template<class InputIterator, class ForwardIterator, class Alloc>
+ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a);
+
+template<class InputIterator, class ForwardIterator, class Alloc>
+ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a);
+
+/*!
+    \struct const_traits
+    \brief Defines the data types for a const iterator.
+*/
+template <class Traits>
+struct const_traits {
+    // Basic types
+    typedef typename Traits::value_type value_type;
+    typedef typename Traits::const_pointer pointer;
+    typedef typename Traits::const_reference reference;
+    typedef typename Traits::size_type size_type;
+    typedef typename Traits::difference_type difference_type;
+
+    // Non-const traits
+    typedef nonconst_traits<Traits> nonconst_self;
+};
+
+/*!
+    \struct nonconst_traits
+    \brief Defines the data types for a non-const iterator.
+*/
+template <class Traits>
+struct nonconst_traits {
+    // Basic types
+    typedef typename Traits::value_type value_type;
+    typedef typename Traits::pointer pointer;
+    typedef typename Traits::reference reference;
+    typedef typename Traits::size_type size_type;
+    typedef typename Traits::difference_type difference_type;
+
+    // Non-const traits
+    typedef nonconst_traits<Traits> nonconst_self;
+};
+
+/*!
+    \struct iterator_wrapper
+    \brief Helper iterator dereference wrapper.
+*/
+template <class Iterator>
+struct iterator_wrapper {
+    mutable Iterator m_it;
+    explicit iterator_wrapper(Iterator it) : m_it(it) {}
+    Iterator operator () () const { return m_it++; }
+private:
+    iterator_wrapper<Iterator>& operator = (const iterator_wrapper<Iterator>&); // do not generate
+};
+
+/*!
+    \struct item_wrapper
+    \brief Helper item dereference wrapper.
+*/
+template <class Pointer, class Value>
+struct item_wrapper {
+    Value m_item;
+    explicit item_wrapper(Value item) : m_item(item) {}
+    Pointer operator () () const { return &m_item; }
+private:
+    item_wrapper<Pointer, Value>& operator = (const item_wrapper<Pointer, Value>&); // do not generate
+};
+
+/*!
+    \struct assign_n
+    \brief Helper functor for assigning n items.
+*/
+template <class Value, class Alloc>
+struct assign_n {
+    typedef typename boost::container::allocator_traits<Alloc>::size_type size_type;
+    size_type m_n;
+    Value m_item;
+    Alloc& m_alloc;
+    assign_n(size_type n, Value item, Alloc& alloc) : m_n(n), m_item(item), m_alloc(alloc) {}
+    template <class Pointer>
+    void operator () (Pointer p) const {
+        uninitialized_fill_n_with_alloc(p, m_n, m_item, m_alloc);
+    }
+private:
+    assign_n<Value, Alloc>& operator = (const assign_n<Value, Alloc>&); // do not generate
+};
+
+/*!
+    \struct assign_range
+    \brief Helper functor for assigning range of items.
+*/
+template <class Iterator, class Alloc>
+struct assign_range {
+    Iterator m_first;
+    Iterator m_last;
+    Alloc&   m_alloc;
+
+    assign_range(const Iterator& first, const Iterator& last, Alloc& alloc)
+        : m_first(first), m_last(last), m_alloc(alloc) {}
+
+    template <class Pointer>
+    void operator () (Pointer p) const {
+        boost::cb_details::uninitialized_copy(m_first, m_last, p, m_alloc);
+    }
+};
+
+template <class Iterator, class Alloc>
+inline assign_range<Iterator, Alloc> make_assign_range(const Iterator& first, const Iterator& last, Alloc& a) {
+    return assign_range<Iterator, Alloc>(first, last, a);
+}
+
+/*!
+    \class capacity_control
+    \brief Capacity controller of the space optimized circular buffer.
+*/
+template <class Size>
+class capacity_control {
+
+    //! The capacity of the space-optimized circular buffer.
+    Size m_capacity;
+
+    //! The lowest guaranteed or minimum capacity of the adapted space-optimized circular buffer.
+    Size m_min_capacity;
+
+public:
+
+    //! Constructor.
+    capacity_control(Size buffer_capacity, Size min_buffer_capacity = 0)
+    : m_capacity(buffer_capacity), m_min_capacity(min_buffer_capacity)
+    { // Check for capacity lower than min_capacity.
+        BOOST_CB_ASSERT(buffer_capacity >= min_buffer_capacity);
+    }
+
+    // Default copy constructor.
+
+    // Default assign operator.
+
+    //! Get the capacity of the space optimized circular buffer.
+    Size capacity() const { return m_capacity; }
+
+    //! Get the minimal capacity of the space optimized circular buffer.
+    Size min_capacity() const { return m_min_capacity; }
+
+    //! Size operator - returns the capacity of the space optimized circular buffer.
+    operator Size() const { return m_capacity; }
+};
+
+/*!
+    \struct iterator
+    \brief Random access iterator for the circular buffer.
+    \param Buff The type of the underlying circular buffer.
+    \param Traits Basic iterator types.
+    \note This iterator is not circular. It was designed
+          for iterating from begin() to end() of the circular buffer.
+*/
+template <class Buff, class Traits>
+struct iterator :
+    public std::iterator<
+    std::random_access_iterator_tag,
+    typename Traits::value_type,
+    typename Traits::difference_type,
+    typename Traits::pointer,
+    typename Traits::reference>
+#if BOOST_CB_ENABLE_DEBUG
+    , public debug_iterator_base
+#endif // #if BOOST_CB_ENABLE_DEBUG
+{
+// Helper types
+
+    //! Base iterator.
+    typedef std::iterator<
+        std::random_access_iterator_tag,
+        typename Traits::value_type,
+        typename Traits::difference_type,
+        typename Traits::pointer,
+        typename Traits::reference> base_iterator;
+
+    //! Non-const iterator.
+    typedef iterator<Buff, typename Traits::nonconst_self> nonconst_self;
+
+// Basic types
+
+    //! The type of the elements stored in the circular buffer.
+    typedef typename base_iterator::value_type value_type;
+
+    //! Pointer to the element.
+    typedef typename base_iterator::pointer pointer;
+
+    //! Reference to the element.
+    typedef typename base_iterator::reference reference;
+
+    //! Size type.
+    typedef typename Traits::size_type size_type;
+
+    //! Difference type.
+    typedef typename base_iterator::difference_type difference_type;
+
+// Member variables
+
+    //! The circular buffer where the iterator points to.
+    const Buff* m_buff;
+
+    //! An internal iterator.
+    pointer m_it;
+
+// Construction & assignment
+
+    // Default copy constructor.
+
+    //! Default constructor.
+    iterator() : m_buff(0), m_it(0) {}
+
+#if BOOST_CB_ENABLE_DEBUG
+
+    //! Copy constructor (used for converting from a non-const to a const iterator).
+    iterator(const nonconst_self& it) : debug_iterator_base(it), m_buff(it.m_buff), m_it(it.m_it) {}
+
+    //! Internal constructor.
+    /*!
+        \note This constructor is not intended to be used directly by the user.
+    */
+    iterator(const Buff* cb, const pointer p) : debug_iterator_base(cb), m_buff(cb), m_it(p) {}
+
+#else
+
+    iterator(const nonconst_self& it) : m_buff(it.m_buff), m_it(it.m_it) {}
+
+    iterator(const Buff* cb, const pointer p) : m_buff(cb), m_it(p) {}
+
+#endif // #if BOOST_CB_ENABLE_DEBUG
+
+    //! Assign operator.
+    iterator& operator = (const iterator& it) {
+        if (this == &it)
+            return *this;
+#if BOOST_CB_ENABLE_DEBUG
+        debug_iterator_base::operator =(it);
+#endif // #if BOOST_CB_ENABLE_DEBUG
+        m_buff = it.m_buff;
+        m_it = it.m_it;
+        return *this;
+    }
+
+// Random access iterator methods
+
+    //! Dereferencing operator.
+    reference operator * () const {
+        BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(m_it != 0);        // check for iterator pointing to end()
+        return *m_it;
+    }
+
+    //! Dereferencing operator.
+    pointer operator -> () const { return &(operator*()); }
+
+    //! Difference operator.
+    template <class Traits0>
+    difference_type operator - (const iterator<Buff, Traits0>& it) const {
+        BOOST_CB_ASSERT(is_valid(m_buff));    // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        return linearize_pointer(*this) - linearize_pointer(it);
+    }
+
+    //! Increment operator (prefix).
+    iterator& operator ++ () {
+        BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(m_it != 0);        // check for iterator pointing to end()
+        m_buff->increment(m_it);
+        if (m_it == m_buff->m_last)
+            m_it = 0;
+        return *this;
+    }
+
+    //! Increment operator (postfix).
+    iterator operator ++ (int) {
+        iterator<Buff, Traits> tmp = *this;
+        ++*this;
+        return tmp;
+    }
+
+    //! Decrement operator (prefix).
+    iterator& operator -- () {
+        BOOST_CB_ASSERT(is_valid(m_buff));        // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(m_it != m_buff->m_first); // check for iterator pointing to begin()
+        if (m_it == 0)
+            m_it = m_buff->m_last;
+        m_buff->decrement(m_it);
+        return *this;
+    }
+
+    //! Decrement operator (postfix).
+    iterator operator -- (int) {
+        iterator<Buff, Traits> tmp = *this;
+        --*this;
+        return tmp;
+    }
+
+    //! Iterator addition.
+    iterator& operator += (difference_type n) {
+        BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        if (n > 0) {
+            BOOST_CB_ASSERT(m_buff->end() - *this >= n); // check for too large n
+            m_it = m_buff->add(m_it, n);
+            if (m_it == m_buff->m_last)
+                m_it = 0;
+        } else if (n < 0) {
+            *this -= -n;
+        }
+        return *this;
+    }
+
+    //! Iterator addition.
+    iterator operator + (difference_type n) const { return iterator<Buff, Traits>(*this) += n; }
+
+    //! Iterator subtraction.
+    iterator& operator -= (difference_type n) {
+        BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        if (n > 0) {
+            BOOST_CB_ASSERT(*this - m_buff->begin() >= n); // check for too large n
+            m_it = m_buff->sub(m_it == 0 ? m_buff->m_last : m_it, n);
+        } else if (n < 0) {
+            *this += -n;
+        }
+        return *this;
+    }
+
+    //! Iterator subtraction.
+    iterator operator - (difference_type n) const { return iterator<Buff, Traits>(*this) -= n; }
+
+    //! Element access operator.
+    reference operator [] (difference_type n) const { return *(*this + n); }
+
+// Equality & comparison
+
+    //! Equality.
+    template <class Traits0>
+    bool operator == (const iterator<Buff, Traits0>& it) const {
+        BOOST_CB_ASSERT(is_valid(m_buff));    // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        return m_it == it.m_it;
+    }
+
+    //! Inequality.
+    template <class Traits0>
+    bool operator != (const iterator<Buff, Traits0>& it) const {
+        BOOST_CB_ASSERT(is_valid(m_buff));    // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        return m_it != it.m_it;
+    }
+
+    //! Less.
+    template <class Traits0>
+    bool operator < (const iterator<Buff, Traits0>& it) const {
+        BOOST_CB_ASSERT(is_valid(m_buff));    // check for uninitialized or invalidated iterator
+        BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator
+        return linearize_pointer(*this) < linearize_pointer(it);
+    }
+
+    //! Greater.
+    template <class Traits0>
+    bool operator > (const iterator<Buff, Traits0>& it) const { return it < *this; }
+
+    //! Less or equal.
+    template <class Traits0>
+    bool operator <= (const iterator<Buff, Traits0>& it) const { return !(it < *this); }
+
+    //! Greater or equal.
+    template <class Traits0>
+    bool operator >= (const iterator<Buff, Traits0>& it) const { return !(*this < it); }
+
+// Helpers
+
+    //! Get a pointer which would point to the same element as the iterator in case the circular buffer is linearized.
+    template <class Traits0>
+    typename Traits0::pointer linearize_pointer(const iterator<Buff, Traits0>& it) const {
+        return it.m_it == 0 ? m_buff->m_buff + m_buff->size() :
+            (it.m_it < m_buff->m_first ? it.m_it + (m_buff->m_end - m_buff->m_first)
+                : m_buff->m_buff + (it.m_it - m_buff->m_first));
+    }
+};
+
+//! Iterator addition.
+template <class Buff, class Traits>
+inline iterator<Buff, Traits>
+operator + (typename Traits::difference_type n, const iterator<Buff, Traits>& it) {
+    return it + n;
+}
+
+/*!
+    \fn ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest)
+    \brief Equivalent of <code>std::uninitialized_copy</code> but with explicit specification of value type.
+*/
+template<class InputIterator, class ForwardIterator, class Alloc>
+inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
+    ForwardIterator next = dest;
+    BOOST_TRY {
+        for (; first != last; ++first, ++dest)
+            boost::container::allocator_traits<Alloc>::construct(a, boost::addressof(*dest), *first);
+    } BOOST_CATCH(...) {
+        for (; next != dest; ++next)
+            boost::container::allocator_traits<Alloc>::destroy(a, boost::addressof(*next));
+        BOOST_RETHROW
+    }
+    BOOST_CATCH_END
+    return dest;
+}
+
+template<class InputIterator, class ForwardIterator, class Alloc>
+ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
+    true_type) {
+    for (; first != last; ++first, ++dest)
+        boost::container::allocator_traits<Alloc>::construct(a, boost::addressof(*dest), boost::move(*first));
+    return dest;
+}
+
+template<class InputIterator, class ForwardIterator, class Alloc>
+ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
+    false_type) {
+    return uninitialized_copy(first, last, dest, a);
+}
+
+/*!
+    \fn ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest)
+    \brief Equivalent of <code>std::uninitialized_copy</code> but with explicit specification of value type and moves elements if they have noexcept move constructors.
+*/
+template<class InputIterator, class ForwardIterator, class Alloc>
+ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
+    typedef typename boost::is_nothrow_move_constructible<typename boost::container::allocator_traits<Alloc>::value_type>::type tag_t;
+    return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t());
+}
+
+/*!
+    \fn void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const T& item, Alloc& alloc)
+    \brief Equivalent of <code>std::uninitialized_fill_n</code> with allocator.
+*/
+template<class ForwardIterator, class Diff, class T, class Alloc>
+inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const T& item, Alloc& alloc) {
+    ForwardIterator next = first;
+    BOOST_TRY {
+        for (; n > 0; ++first, --n)
+            boost::container::allocator_traits<Alloc>::construct(alloc, boost::addressof(*first), item);
+    } BOOST_CATCH(...) {
+        for (; next != first; ++next)
+            boost::container::allocator_traits<Alloc>::destroy(alloc, boost::addressof(*next));
+        BOOST_RETHROW
+    }
+    BOOST_CATCH_END
+}
+
+} // namespace cb_details
+
+} // namespace boost
+
+#if defined(_MSC_VER)
+#  pragma warning(pop)
+#endif
+
+#endif // #if !defined(BOOST_CIRCULAR_BUFFER_DETAILS_HPP)

boost/boost/circular_buffer_fwd.hpp

@@ -0,0 +1,43 @@
+// Forward declaration of the circular buffer and its adaptor.
+
+// Copyright (c) 2003-2008 Jan Gaspar
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See www.boost.org/libs/circular_buffer for documentation.
+
+#if !defined(BOOST_CIRCULAR_BUFFER_FWD_HPP)
+#define BOOST_CIRCULAR_BUFFER_FWD_HPP
+
+#if defined(_MSC_VER)
+    #pragma once
+#endif
+
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_STD_ALLOCATOR)
+    #include <memory>
+#else
+    #include <vector>
+#endif
+
+namespace boost {
+
+#if !defined(BOOST_NO_STD_ALLOCATOR)
+    #define BOOST_CB_DEFAULT_ALLOCATOR(T) std::allocator<T>
+#else
+    #define BOOST_CB_DEFAULT_ALLOCATOR(T) BOOST_DEDUCED_TYPENAME std::vector<T>::allocator_type
+#endif
+
+template <class T, class Alloc = BOOST_CB_DEFAULT_ALLOCATOR(T)>
+class circular_buffer;
+
+template <class T, class Alloc = BOOST_CB_DEFAULT_ALLOCATOR(T)>
+class circular_buffer_space_optimized;
+
+#undef BOOST_CB_DEFAULT_ALLOCATOR
+
+} // namespace boost
+
+#endif // #if !defined(BOOST_CIRCULAR_BUFFER_FWD_HPP)

boost/boost/detail/lightweight_main.hpp

@@ -0,0 +1,36 @@
+//  boost/detail/lightweight_main.hpp  -------------------------------------------------//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <iostream>
+#include <exception>
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                exception reporting main() that calls cpp_main()                      //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+int cpp_main(int argc, char* argv[]);
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    return cpp_main(argc, argv);
+  }
+
+  catch (const std::exception& ex)
+  {
+    std::cout
+    << "\nERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR\n"
+    << "\n****************************** std::exception *****************************\n"
+    << ex.what()
+    << "\n***************************************************************************\n"
+    << std::endl;
+  }
+  return 1;
+}

boost/boost/progress.hpp

@@ -0,0 +1,142 @@
+//  boost progress.hpp header file  ------------------------------------------//
+
+//  Copyright Beman Dawes 1994-99.  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/timer for documentation.
+
+//  Revision History
+//   1 Dec 01  Add leading progress display strings (suggested by Toon Knapen)
+//  20 May 01  Introduce several static_casts<> to eliminate warning messages
+//             (Fixed by Beman, reported by Herve Bronnimann)
+//  12 Jan 01  Change to inline implementation to allow use without library
+//             builds. See docs for more rationale. (Beman Dawes) 
+//  22 Jul 99  Name changed to .hpp
+//  16 Jul 99  Second beta
+//   6 Jul 99  Initial boost version
+
+#ifndef BOOST_PROGRESS_HPP
+#define BOOST_PROGRESS_HPP
+
+#include <boost/timer.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/cstdint.hpp>  // for uintmax_t
+#include <iostream>           // for ostream, cout, etc
+#include <string>             // for string
+
+namespace boost {
+
+//  progress_timer  ----------------------------------------------------------//
+
+//  A progress_timer behaves like a timer except that the destructor displays
+//  an elapsed time message at an appropriate place in an appropriate form.
+
+class progress_timer : public timer, private noncopyable
+{
+  
+ public:
+  explicit progress_timer( std::ostream & os = std::cout )
+     // os is hint; implementation may ignore, particularly in embedded systems
+     : timer(), noncopyable(), m_os(os) {}
+  ~progress_timer()
+  {
+  //  A) Throwing an exception from a destructor is a Bad Thing.
+  //  B) The progress_timer destructor does output which may throw.
+  //  C) A progress_timer is usually not critical to the application.
+  //  Therefore, wrap the I/O in a try block, catch and ignore all exceptions.
+    try
+    {
+      // use istream instead of ios_base to workaround GNU problem (Greg Chicares)
+      std::istream::fmtflags old_flags = m_os.setf( std::istream::fixed,
+                                                   std::istream::floatfield );
+      std::streamsize old_prec = m_os.precision( 2 );
+      m_os << elapsed() << " s\n" // "s" is System International d'Unites std
+                        << std::endl;
+      m_os.flags( old_flags );
+      m_os.precision( old_prec );
+    }
+
+    catch (...) {} // eat any exceptions
+  } // ~progress_timer
+
+ private:
+  std::ostream & m_os;
+};
+
+
+//  progress_display  --------------------------------------------------------//
+
+//  progress_display displays an appropriate indication of 
+//  progress at an appropriate place in an appropriate form.
+
+// NOTE: (Jan 12, 2001) Tried to change unsigned long to boost::uintmax_t, but
+// found some compilers couldn't handle the required conversion to double.
+// Reverted to unsigned long until the compilers catch up. 
+
+class progress_display : private noncopyable
+{
+ public:
+  explicit progress_display( unsigned long expected_count_,
+                             std::ostream & os = std::cout,
+                             const std::string & s1 = "\n", //leading strings
+                             const std::string & s2 = "",
+                             const std::string & s3 = "" )
+   // os is hint; implementation may ignore, particularly in embedded systems
+   : noncopyable(), m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count_); }
+
+  void           restart( unsigned long expected_count_ )
+  //  Effects: display appropriate scale
+  //  Postconditions: count()==0, expected_count()==expected_count_
+  {
+    _count = _next_tic_count = _tic = 0;
+    _expected_count = expected_count_;
+
+    m_os << m_s1 << "0%   10   20   30   40   50   60   70   80   90   100%\n"
+         << m_s2 << "|----|----|----|----|----|----|----|----|----|----|"
+         << std::endl  // endl implies flush, which ensures display
+         << m_s3;
+    if ( !_expected_count ) _expected_count = 1;  // prevent divide by zero
+  } // restart
+
+  unsigned long  operator+=( unsigned long increment )
+  //  Effects: Display appropriate progress tic if needed.
+  //  Postconditions: count()== original count() + increment
+  //  Returns: count().
+  {
+    if ( (_count += increment) >= _next_tic_count ) { display_tic(); }
+    return _count;
+  }
+
+  unsigned long  operator++()           { return operator+=( 1 ); }
+  unsigned long  count() const          { return _count; }
+  unsigned long  expected_count() const { return _expected_count; }
+
+  private:
+  std::ostream &     m_os;  // may not be present in all imps
+  const std::string  m_s1;  // string is more general, safer than 
+  const std::string  m_s2;  //  const char *, and efficiency or size are
+  const std::string  m_s3;  //  not issues
+
+  unsigned long _count, _expected_count, _next_tic_count;
+  unsigned int  _tic;
+  void display_tic()
+  {
+    // use of floating point ensures that both large and small counts
+    // work correctly.  static_cast<>() is also used several places
+    // to suppress spurious compiler warnings. 
+    unsigned int tics_needed = static_cast<unsigned int>((static_cast<double>(_count)
+        / static_cast<double>(_expected_count)) * 50.0);
+    do { m_os << '*' << std::flush; } while ( ++_tic < tics_needed );
+    _next_tic_count = 
+      static_cast<unsigned long>((_tic/50.0) * static_cast<double>(_expected_count));
+    if ( _count == _expected_count ) {
+      if ( _tic < 51 ) m_os << '*';
+      m_os << std::endl;
+      }
+  } // display_tic
+};
+
+} // namespace boost
+
+#endif  // BOOST_PROGRESS_HPP

boost/boost/thread/condition.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_THREAD_CONDITION_HPP
+#define BOOST_THREAD_CONDITION_HPP
+//  (C) Copyright 2007 Anthony Williams
+//
+//  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 <boost/thread/detail/config.hpp>
+
+#if defined BOOST_THREAD_PROVIDES_CONDITION
+
+#include <boost/thread/condition_variable.hpp>
+
+namespace boost
+{
+    typedef condition_variable_any condition;
+}
+
+#endif
+#endif

boost/boost/thread/detail/thread_group.hpp

@@ -0,0 +1,155 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
+#define BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
+// 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)
+// (C) Copyright 2007-9 Anthony Williams
+
+#include <list>
+#include <boost/thread/csbl/memory/unique_ptr.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/lock_guard.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+
+namespace boost
+{
+    class thread_group
+    {
+    private:
+        thread_group(thread_group const&);
+        thread_group& operator=(thread_group const&);
+    public:
+        thread_group() {}
+        ~thread_group()
+        {
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                delete *it;
+            }
+        }
+
+        bool is_this_thread_in()
+        {
+            thread::id id = this_thread::get_id();
+            boost::shared_lock<shared_mutex> guard(m);
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+              if ((*it)->get_id() == id)
+                return true;
+            }
+            return false;
+        }
+
+        bool is_thread_in(thread* thrd)
+        {
+          if(thrd)
+          {
+            thread::id id = thrd->get_id();
+            boost::shared_lock<shared_mutex> guard(m);
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+              if ((*it)->get_id() == id)
+                return true;
+            }
+            return false;
+          }
+          else
+          {
+            return false;
+          }
+        }
+
+        template<typename F>
+        thread* create_thread(F threadfunc)
+        {
+            boost::lock_guard<shared_mutex> guard(m);
+            boost::csbl::unique_ptr<thread> new_thread(new thread(threadfunc));
+            threads.push_back(new_thread.get());
+            return new_thread.release();
+        }
+
+        void add_thread(thread* thrd)
+        {
+            if(thrd)
+            {
+                BOOST_THREAD_ASSERT_PRECONDITION( ! is_thread_in(thrd) ,
+                    thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost::thread_group: trying to add a duplicated thread")
+                );
+
+                boost::lock_guard<shared_mutex> guard(m);
+                threads.push_back(thrd);
+            }
+        }
+
+        void remove_thread(thread* thrd)
+        {
+            boost::lock_guard<shared_mutex> guard(m);
+            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
+            if(it!=threads.end())
+            {
+                threads.erase(it);
+            }
+        }
+
+        void join_all()
+        {
+            BOOST_THREAD_ASSERT_PRECONDITION( ! is_this_thread_in() ,
+                thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost::thread_group: trying joining itself")
+            );
+            boost::shared_lock<shared_mutex> guard(m);
+
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+              if ((*it)->joinable())
+                (*it)->join();
+            }
+        }
+
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+        void interrupt_all()
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->interrupt();
+            }
+        }
+#endif
+
+        size_t size() const
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            return threads.size();
+        }
+
+    private:
+        std::list<thread*> threads;
+        mutable shared_mutex m;
+    };
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

boost/boost/thread/pthread/shared_mutex.hpp

@@ -0,0 +1,716 @@
+#ifndef BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
+
+//  (C) Copyright 2006-8 Anthony Williams
+//  (C) Copyright 2012 Vicente J. Botet Escriba
+//
+//  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 <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#include <boost/thread/detail/thread_interruption.hpp>
+#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif
+#include <boost/thread/detail/delete.hpp>
+#include <boost/assert.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class shared_mutex
+    {
+    private:
+        class state_data
+        {
+        public:
+            state_data () :
+              shared_count(0),
+              exclusive(false),
+              upgrade(false),
+              exclusive_waiting_blocked(false)
+            {}
+
+            void assert_free() const
+            {
+                BOOST_ASSERT( ! exclusive );
+                BOOST_ASSERT( ! upgrade );
+                BOOST_ASSERT( shared_count==0 );
+            }
+
+            void assert_locked() const
+            {
+                BOOST_ASSERT( exclusive );
+                BOOST_ASSERT( shared_count==0 );
+                BOOST_ASSERT( ! upgrade );
+            }
+
+            void assert_lock_shared () const
+            {
+                BOOST_ASSERT( ! exclusive );
+                BOOST_ASSERT( shared_count>0 );
+                //BOOST_ASSERT( (! upgrade) || (shared_count>1));
+                // if upgraded there are at least 2 threads sharing the mutex,
+                // except when unlock_upgrade_and_lock has decreased the number of readers but has not taken yet exclusive ownership.
+            }
+
+            void assert_lock_upgraded () const
+            {
+                BOOST_ASSERT( ! exclusive );
+                BOOST_ASSERT(  upgrade );
+                BOOST_ASSERT(  shared_count>0 );
+            }
+
+            void assert_lock_not_upgraded () const
+            {
+                BOOST_ASSERT(  ! upgrade );
+            }
+
+            bool can_lock () const
+            {
+                return ! (shared_count || exclusive);
+            }
+
+            void exclusive_blocked (bool blocked)
+            {
+                exclusive_waiting_blocked = blocked;
+            }
+
+            void lock ()
+            {
+                exclusive = true;
+            }
+
+            void unlock ()
+            {
+                exclusive = false;
+                exclusive_waiting_blocked = false;
+            }
+
+            bool can_lock_shared () const
+            {
+                return ! (exclusive || exclusive_waiting_blocked);
+            }
+
+            bool more_shared () const
+            {
+                return shared_count > 0 ;
+            }
+            unsigned get_shared_count () const
+            {
+                return shared_count ;
+            }
+            unsigned  lock_shared ()
+            {
+                return ++shared_count;
+            }
+
+
+            void unlock_shared ()
+            {
+                --shared_count;
+            }
+
+            bool unlock_shared_downgrades()
+            {
+                  if (upgrade) {
+                      upgrade=false;
+                      exclusive=true;
+                      return true;
+                  } else {
+                      exclusive_waiting_blocked=false;
+                      return false;
+                  }
+            }
+
+            void lock_upgrade ()
+            {
+                ++shared_count;
+                upgrade=true;
+            }
+            bool can_lock_upgrade () const
+            {
+                return ! (exclusive || exclusive_waiting_blocked || upgrade);
+            }
+
+            void unlock_upgrade ()
+            {
+                upgrade=false;
+                --shared_count;
+            }
+
+        //private:
+            unsigned shared_count;
+            bool exclusive;
+            bool upgrade;
+            bool exclusive_waiting_blocked;
+        };
+
+
+
+        state_data state;
+        boost::mutex state_change;
+        boost::condition_variable shared_cond;
+        boost::condition_variable exclusive_cond;
+        boost::condition_variable upgrade_cond;
+
+        void release_waiters()
+        {
+            exclusive_cond.notify_one();
+            shared_cond.notify_all();
+        }
+
+    public:
+
+        BOOST_THREAD_NO_COPYABLE(shared_mutex)
+
+        shared_mutex()
+        {
+        }
+
+        ~shared_mutex()
+        {
+        }
+
+        void lock_shared()
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+            while(!state.can_lock_shared())
+            {
+                shared_cond.wait(lk);
+            }
+            state.lock_shared();
+        }
+
+        bool try_lock_shared()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+
+            if(!state.can_lock_shared())
+            {
+                return false;
+            }
+            state.lock_shared();
+            return true;
+        }
+
+#if defined BOOST_THREAD_USES_DATETIME
+        bool timed_lock_shared(system_time const& timeout)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+
+            while(!state.can_lock_shared())
+            {
+                if(!shared_cond.timed_wait(lk,timeout))
+                {
+                    return false;
+                }
+            }
+            state.lock_shared();
+            return true;
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock_shared(TimeDuration const & relative_time)
+        {
+            return timed_lock_shared(get_system_time()+relative_time);
+        }
+#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+          boost::this_thread::disable_interruption do_not_disturb;
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+
+          while(!state.can_lock_shared())
+          //while(state.exclusive || state.exclusive_waiting_blocked)
+          {
+              if(cv_status::timeout==shared_cond.wait_until(lk,abs_time))
+              {
+                  return false;
+              }
+          }
+          state.lock_shared();
+          return true;
+        }
+#endif
+        void unlock_shared()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_lock_shared();
+            state.unlock_shared();
+            if (! state.more_shared())
+            {
+                if (state.upgrade)
+                {
+                    // As there is a thread doing a unlock_upgrade_and_lock that is waiting for ! state.more_shared()
+                    // avoid other threads to lock, lock_upgrade or lock_shared, so only this thread is notified.
+                    state.upgrade=false;
+                    state.exclusive=true;
+                    //lk.unlock();
+                    upgrade_cond.notify_one();
+                }
+                else
+                {
+                    state.exclusive_waiting_blocked=false;
+                    //lk.unlock();
+                }
+                release_waiters();
+            }
+        }
+
+        void lock()
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+
+            while (state.shared_count || state.exclusive)
+            {
+                state.exclusive_waiting_blocked=true;
+                exclusive_cond.wait(lk);
+            }
+            state.exclusive=true;
+        }
+
+#if defined BOOST_THREAD_USES_DATETIME
+        bool timed_lock(system_time const& timeout)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+
+            while(state.shared_count || state.exclusive)
+            {
+                state.exclusive_waiting_blocked=true;
+                if(!exclusive_cond.timed_wait(lk,timeout))
+                {
+                    if(state.shared_count || state.exclusive)
+                    {
+                        state.exclusive_waiting_blocked=false;
+                        release_waiters();
+                        return false;
+                    }
+                    break;
+                }
+            }
+            state.exclusive=true;
+            return true;
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            return timed_lock(get_system_time()+relative_time);
+        }
+#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+          boost::this_thread::disable_interruption do_not_disturb;
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+
+          while(state.shared_count || state.exclusive)
+          {
+              state.exclusive_waiting_blocked=true;
+              if(cv_status::timeout == exclusive_cond.wait_until(lk,abs_time))
+              {
+                  if(state.shared_count || state.exclusive)
+                  {
+                      state.exclusive_waiting_blocked=false;
+                      release_waiters();
+                      return false;
+                  }
+                  break;
+              }
+          }
+          state.exclusive=true;
+          return true;
+        }
+#endif
+
+        bool try_lock()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+
+            if(state.shared_count || state.exclusive)
+            {
+                return false;
+            }
+            else
+            {
+                state.exclusive=true;
+                return true;
+            }
+
+        }
+
+        void unlock()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_locked();
+            state.exclusive=false;
+            state.exclusive_waiting_blocked=false;
+            state.assert_free();
+            release_waiters();
+        }
+
+        void lock_upgrade()
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+            {
+                shared_cond.wait(lk);
+            }
+            state.lock_shared();
+            state.upgrade=true;
+        }
+
+#if defined BOOST_THREAD_USES_DATETIME
+        bool timed_lock_upgrade(system_time const& timeout)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+            {
+                if(!shared_cond.timed_wait(lk,timeout))
+                {
+                    if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+                    {
+                        return false;
+                    }
+                    break;
+                }
+            }
+            state.lock_shared();
+            state.upgrade=true;
+            return true;
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock_upgrade(TimeDuration const & relative_time)
+        {
+            return timed_lock_upgrade(get_system_time()+relative_time);
+        }
+#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+          boost::this_thread::disable_interruption do_not_disturb;
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+          {
+              if(cv_status::timeout == shared_cond.wait_until(lk,abs_time))
+              {
+                  if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+                  {
+                      return false;
+                  }
+                  break;
+              }
+          }
+          state.lock_shared();
+          state.upgrade=true;
+          return true;
+        }
+#endif
+        bool try_lock_upgrade()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+            {
+                return false;
+            }
+            else
+            {
+                state.lock_shared();
+                state.upgrade=true;
+                state.assert_lock_upgraded();
+                return true;
+            }
+        }
+
+        void unlock_upgrade()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            //state.upgrade=false;
+            state.unlock_upgrade();
+            if(! state.more_shared() )
+            {
+                state.exclusive_waiting_blocked=false;
+                release_waiters();
+            } else {
+                shared_cond.notify_all();
+            }
+        }
+
+        // Upgrade <-> Exclusive
+        void unlock_upgrade_and_lock()
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            boost::this_thread::disable_interruption do_not_disturb;
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_lock_upgraded();
+            state.unlock_shared();
+            while (state.more_shared())
+            {
+                upgrade_cond.wait(lk);
+            }
+            state.upgrade=false;
+            state.exclusive=true;
+            state.assert_locked();
+        }
+
+        void unlock_and_lock_upgrade()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_locked();
+            state.exclusive=false;
+            state.upgrade=true;
+            state.lock_shared();
+            state.exclusive_waiting_blocked=false;
+            state.assert_lock_upgraded();
+            release_waiters();
+        }
+
+        bool try_unlock_upgrade_and_lock()
+        {
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_upgraded();
+          if(    !state.exclusive
+              && !state.exclusive_waiting_blocked
+              && state.upgrade
+              && state.shared_count==1)
+          {
+            state.shared_count=0;
+            state.exclusive=true;
+            state.upgrade=false;
+            state.assert_locked();
+            return true;
+          }
+          return false;
+        }
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool
+        try_unlock_upgrade_and_lock_for(
+                                const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_unlock_upgrade_and_lock_until(
+                                 chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool
+        try_unlock_upgrade_and_lock_until(
+                          const chrono::time_point<Clock, Duration>& abs_time)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+          boost::this_thread::disable_interruption do_not_disturb;
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_upgraded();
+          if (state.shared_count != 1)
+          {
+              for (;;)
+              {
+                cv_status status = shared_cond.wait_until(lk,abs_time);
+                if (state.shared_count == 1)
+                  break;
+                if(status == cv_status::timeout)
+                  return false;
+              }
+          }
+          state.upgrade=false;
+          state.exclusive=true;
+          state.exclusive_waiting_blocked=false;
+          state.shared_count=0;
+          return true;
+        }
+#endif
+
+        // Shared <-> Exclusive
+        void unlock_and_lock_shared()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_locked();
+            state.exclusive=false;
+            state.lock_shared();
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+
+#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+        bool try_unlock_shared_and_lock()
+        {
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
+          if(    !state.exclusive
+              && !state.exclusive_waiting_blocked
+              && !state.upgrade
+              && state.shared_count==1)
+          {
+            state.shared_count=0;
+            state.exclusive=true;
+            return true;
+          }
+          return false;
+        }
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+            bool
+            try_unlock_shared_and_lock_for(
+                                const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_unlock_shared_and_lock_until(
+                                 chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+            bool
+            try_unlock_shared_and_lock_until(
+                          const chrono::time_point<Clock, Duration>& abs_time)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+          boost::this_thread::disable_interruption do_not_disturb;
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
+          if (state.shared_count != 1)
+          {
+              for (;;)
+              {
+                cv_status status = shared_cond.wait_until(lk,abs_time);
+                if (state.shared_count == 1)
+                  break;
+                if(status == cv_status::timeout)
+                  return false;
+              }
+          }
+          state.upgrade=false;
+          state.exclusive=true;
+          state.exclusive_waiting_blocked=false;
+          state.shared_count=0;
+          return true;
+        }
+#endif
+#endif
+
+        // Shared <-> Upgrade
+        void unlock_upgrade_and_lock_shared()
+        {
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_lock_upgraded();
+            state.upgrade=false;
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+
+#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+        bool try_unlock_shared_and_lock_upgrade()
+        {
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
+          if(    !state.exclusive
+              && !state.exclusive_waiting_blocked
+              && !state.upgrade
+              )
+          {
+            state.upgrade=true;
+            return true;
+          }
+          return false;
+        }
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+            bool
+            try_unlock_shared_and_lock_upgrade_for(
+                                const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_unlock_shared_and_lock_upgrade_until(
+                                 chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+            bool
+            try_unlock_shared_and_lock_upgrade_until(
+                          const chrono::time_point<Clock, Duration>& abs_time)
+        {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+          boost::this_thread::disable_interruption do_not_disturb;
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
+          if(    state.exclusive
+              || state.exclusive_waiting_blocked
+              || state.upgrade
+              )
+          {
+              for (;;)
+              {
+                cv_status status = exclusive_cond.wait_until(lk,abs_time);
+                if(    ! state.exclusive
+                    && ! state.exclusive_waiting_blocked
+                    && ! state.upgrade
+                    )
+                  break;
+                if(status == cv_status::timeout)
+                  return false;
+              }
+          }
+          state.upgrade=true;
+          return true;
+        }
+#endif
+#endif
+    };
+
+    typedef shared_mutex upgrade_mutex;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

boost/boost/thread/shared_mutex.hpp

@@ -0,0 +1,50 @@
+#ifndef BOOST_THREAD_SHARED_MUTEX_HPP
+#define BOOST_THREAD_SHARED_MUTEX_HPP
+
+//  shared_mutex.hpp
+//
+//  (C) Copyright 2007 Anthony Williams
+//  (C) Copyright 2011-2012 Vicente J. Botet Escriba
+//
+//  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 <boost/thread/detail/config.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#if defined(BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN)
+#include <boost/thread/pthread/shared_mutex.hpp>
+#else
+#include <boost/thread/win32/shared_mutex.hpp>
+#endif
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+//#include <boost/thread/v2/shared_mutex.hpp>
+#include <boost/thread/pthread/shared_mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#include <boost/thread/lockable_traits.hpp>
+
+namespace boost
+{
+  typedef shared_mutex shared_timed_mutex;
+  namespace sync
+  {
+#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
+    template<>
+    struct is_basic_lockable<shared_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_lockable<shared_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+#endif
+
+  }
+}
+
+#endif

boost/boost/thread/thread.hpp

@@ -0,0 +1,16 @@
+#ifndef BOOST_THREAD_THREAD_HPP
+#define BOOST_THREAD_THREAD_HPP
+
+//  thread.hpp
+//
+//  (C) Copyright 2007-8 Anthony Williams
+//
+//  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 <boost/thread/thread_only.hpp>
+#include <boost/thread/detail/thread_group.hpp>
+
+
+#endif

boost/boost/thread/win32/shared_mutex.hpp

@@ -0,0 +1,903 @@
+#ifndef BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
+#define BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
+
+//  (C) Copyright 2006-8 Anthony Williams
+//  (C) Copyright 2011-2012 Vicente J. Botet Escriba
+//
+//  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 <boost/assert.hpp>
+#include <boost/detail/interlocked.hpp>
+#include <boost/thread/win32/thread_primitives.hpp>
+#include <boost/static_assert.hpp>
+#include <limits.h>
+#include <boost/thread/thread_time.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif
+#include <boost/thread/detail/delete.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class shared_mutex
+    {
+    private:
+        struct state_data
+        {
+            unsigned shared_count:11,
+                shared_waiting:11,
+                exclusive:1,
+                upgrade:1,
+                exclusive_waiting:7,
+                exclusive_waiting_blocked:1;
+
+            friend bool operator==(state_data const& lhs,state_data const& rhs)
+            {
+                return *reinterpret_cast<unsigned const*>(&lhs)==*reinterpret_cast<unsigned const*>(&rhs);
+            }
+        };
+
+
+        template<typename T>
+        T interlocked_compare_exchange(T* target,T new_value,T comparand)
+        {
+            BOOST_STATIC_ASSERT(sizeof(T)==sizeof(long));
+            long const res=BOOST_INTERLOCKED_COMPARE_EXCHANGE(reinterpret_cast<long*>(target),
+                                                              *reinterpret_cast<long*>(&new_value),
+                                                              *reinterpret_cast<long*>(&comparand));
+            return *reinterpret_cast<T const*>(&res);
+        }
+
+        enum
+        {
+            unlock_sem = 0,
+            exclusive_sem = 1
+        };
+
+        state_data state;
+        detail::win32::handle semaphores[2];
+        detail::win32::handle upgrade_sem;
+
+        void release_waiters(state_data old_state)
+        {
+            if(old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+            }
+
+            if(old_state.shared_waiting || old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+            }
+        }
+        void release_shared_waiters(state_data old_state)
+        {
+            if(old_state.shared_waiting || old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+            }
+        }
+
+    public:
+        BOOST_THREAD_NO_COPYABLE(shared_mutex)
+        shared_mutex()
+        {
+            semaphores[unlock_sem]=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            semaphores[exclusive_sem]=detail::win32::create_anonymous_semaphore_nothrow(0,LONG_MAX);
+            if (!semaphores[exclusive_sem])
+            {
+              detail::win32::release_semaphore(semaphores[unlock_sem],LONG_MAX);
+              boost::throw_exception(thread_resource_error());
+            }
+            upgrade_sem=detail::win32::create_anonymous_semaphore_nothrow(0,LONG_MAX);
+            if (!upgrade_sem)
+            {
+              detail::win32::release_semaphore(semaphores[unlock_sem],LONG_MAX);
+              detail::win32::release_semaphore(semaphores[exclusive_sem],LONG_MAX);
+              boost::throw_exception(thread_resource_error());
+            }
+            state_data state_={0,0,0,0,0,0};
+            state=state_;
+        }
+
+        ~shared_mutex()
+        {
+            detail::win32::CloseHandle(upgrade_sem);
+            detail::win32::CloseHandle(semaphores[unlock_sem]);
+            detail::win32::CloseHandle(semaphores[exclusive_sem]);
+        }
+
+        bool try_lock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
+                {
+                    ++new_state.shared_count;
+                    if(!new_state.shared_count)
+                    {
+                        return false;
+                    }
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return !(old_state.exclusive| old_state.exclusive_waiting_blocked);
+        }
+
+        void lock_shared()
+        {
+
+#if defined BOOST_THREAD_USES_DATETIME
+            BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
+#else
+            BOOST_VERIFY(try_lock_shared_until(chrono::steady_clock::now()));
+#endif
+        }
+
+#if defined BOOST_THREAD_USES_DATETIME
+        template<typename TimeDuration>
+        bool timed_lock_shared(TimeDuration const & relative_time)
+        {
+            return timed_lock_shared(get_system_time()+relative_time);
+        }
+        bool timed_lock_shared(boost::system_time const& wait_until)
+        {
+            for(;;)
+            {
+                state_data old_state=state;
+                for(;;)
+                {
+                    state_data new_state=old_state;
+                    if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                    {
+                        ++new_state.shared_waiting;
+                        if(!new_state.shared_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                    }
+                    else
+                    {
+                        ++new_state.shared_count;
+                        if(!new_state.shared_count)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+
+                if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+                {
+                    return true;
+                }
+
+                unsigned long const res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
+                if(res==detail::win32::timeout)
+                {
+                    for(;;)
+                    {
+                        state_data new_state=old_state;
+                        if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                        {
+                            if(new_state.shared_waiting)
+                            {
+                                --new_state.shared_waiting;
+                            }
+                        }
+                        else
+                        {
+                            ++new_state.shared_count;
+                            if(!new_state.shared_count)
+                            {
+                                return false;
+                            }
+                        }
+
+                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                        if(current_state==old_state)
+                        {
+                            break;
+                        }
+                        old_state=current_state;
+                    }
+
+                    if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+
+                BOOST_ASSERT(res==0);
+            }
+        }
+#endif
+
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_lock_shared_until(s_now + ceil<system_clock::duration>(t - c_now));
+        }
+        template <class Duration>
+        bool try_lock_shared_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt;
+          return try_lock_shared_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch())));
+        }
+        bool try_lock_shared_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp)
+        {
+          for(;;)
+          {
+            state_data old_state=state;
+            for(;;)
+            {
+              state_data new_state=old_state;
+              if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+              {
+                  ++new_state.shared_waiting;
+                  if(!new_state.shared_waiting)
+                  {
+                      boost::throw_exception(boost::lock_error());
+                  }
+              }
+              else
+              {
+                  ++new_state.shared_count;
+                  if(!new_state.shared_count)
+                  {
+                      boost::throw_exception(boost::lock_error());
+                  }
+              }
+
+              state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+              if(current_state==old_state)
+              {
+                  break;
+              }
+              old_state=current_state;
+            }
+
+            if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+            {
+              return true;
+            }
+
+            chrono::system_clock::time_point n = chrono::system_clock::now();
+            unsigned long res;
+            if (tp>n) {
+              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-n);
+              res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],
+                static_cast<unsigned long>(rel_time.count()), 0);
+            } else {
+              res=detail::win32::timeout;
+            }
+            if(res==detail::win32::timeout)
+            {
+              for(;;)
+              {
+                state_data new_state=old_state;
+                if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                {
+                  if(new_state.shared_waiting)
+                  {
+                      --new_state.shared_waiting;
+                  }
+                }
+                else
+                {
+                  ++new_state.shared_count;
+                  if(!new_state.shared_count)
+                  {
+                      return false;
+                  }
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+              }
+
+              if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+              {
+                return true;
+              }
+              return false;
+            }
+
+            BOOST_ASSERT(res==0);
+          }
+        }
+#endif
+
+        void unlock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                bool const last_reader=!--new_state.shared_count;
+
+                if(last_reader)
+                {
+                    if(new_state.upgrade)
+                    {
+                        new_state.upgrade=false;
+                        new_state.exclusive=true;
+                    }
+                    else
+                    {
+                        if(new_state.exclusive_waiting)
+                        {
+                            --new_state.exclusive_waiting;
+                            new_state.exclusive_waiting_blocked=false;
+                        }
+                        new_state.shared_waiting=0;
+                    }
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    if(last_reader)
+                    {
+                        if(old_state.upgrade)
+                        {
+                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
+                        }
+                        else
+                        {
+                            release_waiters(old_state);
+                        }
+                    }
+                    break;
+                }
+                old_state=current_state;
+            }
+        }
+
+        void lock()
+        {
+
+#if defined BOOST_THREAD_USES_DATETIME
+            BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
+#else
+            BOOST_VERIFY(try_lock_until(chrono::steady_clock::now()));
+#endif
+        }
+
+#if defined BOOST_THREAD_USES_DATETIME
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            return timed_lock(get_system_time()+relative_time);
+        }
+#endif
+
+        bool try_lock()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(new_state.shared_count || new_state.exclusive)
+                {
+                    return false;
+                }
+                else
+                {
+                    new_state.exclusive=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return true;
+        }
+
+
+#if defined BOOST_THREAD_USES_DATETIME
+        bool timed_lock(boost::system_time const& wait_until)
+        {
+            for(;;)
+            {
+                state_data old_state=state;
+
+                for(;;)
+                {
+                    state_data new_state=old_state;
+                    if(new_state.shared_count || new_state.exclusive)
+                    {
+                        ++new_state.exclusive_waiting;
+                        if(!new_state.exclusive_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+
+                        new_state.exclusive_waiting_blocked=true;
+                    }
+                    else
+                    {
+                        new_state.exclusive=true;
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+
+                if(!old_state.shared_count && !old_state.exclusive)
+                {
+                    return true;
+                }
+                #ifndef UNDER_CE
+                const bool wait_all = true;
+                #else
+                const bool wait_all = false;
+                #endif
+                unsigned long const wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
+                if(wait_res==detail::win32::timeout)
+                {
+                    for(;;)
+                    {
+                        bool must_notify = false;
+                        state_data new_state=old_state;
+                        if(new_state.shared_count || new_state.exclusive)
+                        {
+                            if(new_state.exclusive_waiting)
+                            {
+                                if(!--new_state.exclusive_waiting)
+                                {
+                                    new_state.exclusive_waiting_blocked=false;
+                                    must_notify = true;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            new_state.exclusive=true;
+                        }
+
+                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                        if (must_notify)
+                        {
+                          BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                        }
+
+                        if(current_state==old_state)
+                        {
+                            break;
+                        }
+                        old_state=current_state;
+                    }
+                    if(!old_state.shared_count && !old_state.exclusive)
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+                BOOST_ASSERT(wait_res<2);
+            }
+        }
+#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_lock_until(s_now + ceil<system_clock::duration>(t - c_now));
+        }
+        template <class Duration>
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt;
+          return try_lock_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch())));
+        }
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp)
+        {
+          for(;;)
+          {
+            state_data old_state=state;
+
+            for(;;)
+            {
+              state_data new_state=old_state;
+              if(new_state.shared_count || new_state.exclusive)
+              {
+                ++new_state.exclusive_waiting;
+                if(!new_state.exclusive_waiting)
+                {
+                    boost::throw_exception(boost::lock_error());
+                }
+
+                new_state.exclusive_waiting_blocked=true;
+              }
+              else
+              {
+                new_state.exclusive=true;
+              }
+
+              state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+              if(current_state==old_state)
+              {
+                break;
+              }
+              old_state=current_state;
+            }
+
+            if(!old_state.shared_count && !old_state.exclusive)
+            {
+                return true;
+            }
+            #ifndef UNDER_CE
+            const bool wait_all = true;
+            #else
+            const bool wait_all = false;
+            #endif
+
+            chrono::system_clock::time_point n = chrono::system_clock::now();
+            unsigned long wait_res;
+            if (tp>n) {
+              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
+              wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,
+                  static_cast<unsigned long>(rel_time.count()), 0);
+            } else {
+              wait_res=detail::win32::timeout;
+            }
+            if(wait_res==detail::win32::timeout)
+            {
+              for(;;)
+              {
+                bool must_notify = false;
+                state_data new_state=old_state;
+                if(new_state.shared_count || new_state.exclusive)
+                {
+                  if(new_state.exclusive_waiting)
+                  {
+                    if(!--new_state.exclusive_waiting)
+                    {
+                      new_state.exclusive_waiting_blocked=false;
+                      must_notify = true;
+                    }
+                  }
+                }
+                else
+                {
+                  new_state.exclusive=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if (must_notify)
+                {
+                  BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                }
+                if(current_state==old_state)
+                {
+                  break;
+                }
+                old_state=current_state;
+              }
+              if(!old_state.shared_count && !old_state.exclusive)
+              {
+                return true;
+              }
+              return false;
+            }
+            BOOST_ASSERT(wait_res<2);
+          }
+        }
+#endif
+
+        void unlock()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.exclusive=false;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+
+        void lock_upgrade()
+        {
+            for(;;)
+            {
+                state_data old_state=state;
+                for(;;)
+                {
+                    state_data new_state=old_state;
+                    if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
+                    {
+                        ++new_state.shared_waiting;
+                        if(!new_state.shared_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                    }
+                    else
+                    {
+                        ++new_state.shared_count;
+                        if(!new_state.shared_count)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                        new_state.upgrade=true;
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+
+                if(!(old_state.exclusive|| old_state.exclusive_waiting_blocked|| old_state.upgrade))
+                {
+                    return;
+                }
+
+                BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],detail::win32::infinite, 0));
+            }
+        }
+
+        bool try_lock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
+                {
+                    return false;
+                }
+                else
+                {
+                    ++new_state.shared_count;
+                    if(!new_state.shared_count)
+                    {
+                        return false;
+                    }
+                    new_state.upgrade=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return true;
+        }
+
+        void unlock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.upgrade=false;
+                bool const last_reader=!--new_state.shared_count;
+
+                new_state.shared_waiting=0;
+                if(last_reader)
+                {
+                    if(new_state.exclusive_waiting)
+                    {
+                        --new_state.exclusive_waiting;
+                        new_state.exclusive_waiting_blocked=false;
+                    }
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    if(last_reader)
+                    {
+                        release_waiters(old_state);
+                    }
+                    else {
+                        release_shared_waiters(old_state);
+                    }
+                    // #7720
+                    //else {
+                    //    release_waiters(old_state);
+                    //}
+                    break;
+                }
+                old_state=current_state;
+            }
+        }
+
+        void unlock_upgrade_and_lock()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                bool const last_reader=!--new_state.shared_count;
+
+                if(last_reader)
+                {
+                    new_state.upgrade=false;
+                    new_state.exclusive=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    if(!last_reader)
+                    {
+                        BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
+                    }
+                    break;
+                }
+                old_state=current_state;
+            }
+        }
+
+        void unlock_and_lock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.exclusive=false;
+                new_state.upgrade=true;
+                ++new_state.shared_count;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+//        bool try_unlock_upgrade_and_lock()
+//        {
+//          return false;
+//        }
+//#ifdef BOOST_THREAD_USES_CHRONO
+//        template <class Rep, class Period>
+//        bool
+//        try_unlock_upgrade_and_lock_for(
+//                                const chrono::duration<Rep, Period>& rel_time)
+//        {
+//          return try_unlock_upgrade_and_lock_until(
+//                                 chrono::steady_clock::now() + rel_time);
+//        }
+//        template <class Clock, class Duration>
+//        bool
+//        try_unlock_upgrade_and_lock_until(
+//                          const chrono::time_point<Clock, Duration>& abs_time)
+//        {
+//          return false;
+//        }
+//#endif
+
+        void unlock_and_lock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.exclusive=false;
+                ++new_state.shared_count;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+        void unlock_upgrade_and_lock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.upgrade=false;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+
+    };
+    typedef shared_mutex upgrade_mutex;
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

boost/boost/tr1/detail/config.hpp

@@ -0,0 +1,173 @@
+//  (C) Copyright John Maddock 2005-7.
+//  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)
+
+#ifndef BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
+#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
+
+#include <cstddef>
+
+#if (defined(__GNUC__) && !(defined(linux) || defined(__linux) || defined(__linux__))) \
+   || (!defined(__FreeBSD__) && defined(__GNUC__)) \
+   || (!defined(_AIX) && defined(__IBMCPP__)  && (__IBMCPP__ >= 800)) 
+   // Disable use of #include_next on Linux as typically we are installed in a 
+   // directory that is searched *after* the std lib include path.
+#if !defined(BOOST_HAS_INCLUDE_NEXT)
+#  define BOOST_HAS_INCLUDE_NEXT
+#endif
+// Need to find out if we're using GLIBC:
+#ifdef BOOST_TR1_UTILITY_INCLUDED
+// Oops we're in a recursive include path!!
+// Need to include utility, or some std lib header,
+// but *not* via <utility> or <boost/config/no_tr1/utility.hpp>
+#  ifndef BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_CONFIG_RECURSION
+#  endif
+#  if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
+#     include_next <utility>
+#  else
+#     include BOOST_TR1_STD_HEADER(utility)
+#  endif
+#  ifdef BOOST_TR1_NO_CONFIG_RECURSION
+#     undef BOOST_TR1_NO_CONFIG_RECURSION
+#     undef BOOST_TR1_NO_RECURSION
+#  endif
+#else
+#include <boost/config/no_tr1/utility.hpp>
+#endif
+#endif
+
+#if defined(__GLIBCXX__) && !defined(BOOST_TR1_PATH)
+#  define BOOST_TR1_PATH(name) tr1/name
+#endif
+#if !defined(BOOST_TR1_PATH)
+#  define BOOST_TR1_PATH(name) name
+#endif
+
+#define BOOST_TR1_HEADER(name) <BOOST_TR1_PATH(name)>
+
+// Can't use BOOST_WORKAROUND here, it leads to recursive includes:
+#if (defined(__BORLANDC__) && (__BORLANDC__ <= 0x600))
+#  define BOOST_TR1_USE_OLD_TUPLE
+#endif
+
+#ifdef __IBMCPP_TR1__
+   // turn on support for everything:
+#  define BOOST_HAS_TR1
+#endif
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#  define BOOST_HAS_TR1_COMPLEX_OVERLOADS
+#  define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
+#endif
+
+#ifdef BOOST_HAS_TR1
+   // turn on support for everything:
+#  define BOOST_HAS_TR1_ARRAY
+#  define BOOST_HAS_TR1_COMPLEX_OVERLOADS
+#  define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
+#  define BOOST_HAS_TR1_REFERENCE_WRAPPER
+#  define BOOST_HAS_TR1_RESULT_OF
+#  define BOOST_HAS_TR1_MEM_FN
+#  define BOOST_HAS_TR1_BIND
+#  define BOOST_HAS_TR1_FUNCTION
+#  define BOOST_HAS_TR1_HASH
+#  define BOOST_HAS_TR1_SHARED_PTR
+#  define BOOST_HAS_TR1_RANDOM
+#  define BOOST_HAS_TR1_REGEX
+#  define BOOST_HAS_TR1_TUPLE
+#  define BOOST_HAS_TR1_TYPE_TRAITS
+#  define BOOST_HAS_TR1_UTILITY
+#  define BOOST_HAS_TR1_UNORDERED_MAP
+#  define BOOST_HAS_TR1_UNORDERED_SET
+#  define BOOST_HAS_TR1_CMATH
+
+#endif
+
+#if defined(__MWERKS__) && (__MWERKS__ >= 0x3205)
+//
+// Very preliminary MWCW support, may not be right:
+//
+#  define BOOST_HAS_TR1_SHARED_PTR
+#  define BOOST_HAS_TR1_REFERENCE_WRAPPER
+#  define BOOST_HAS_TR1_FUNCTION
+#  define BOOST_HAS_TR1_TUPLE
+#  define BOOST_HAS_TR1_RESULT_OF
+#endif
+
+#ifdef BOOST_HAS_GCC_TR1
+   // turn on support for everything in gcc 4.0.x:
+#  define BOOST_HAS_TR1_ARRAY
+#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 403
+//#  define BOOST_HAS_TR1_COMPLEX_OVERLOADS
+#  define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
+#endif
+#  define BOOST_HAS_TR1_REFERENCE_WRAPPER
+#  define BOOST_HAS_TR1_RESULT_OF
+#  define BOOST_HAS_TR1_MEM_FN
+#  define BOOST_HAS_TR1_BIND
+#  define BOOST_HAS_TR1_FUNCTION
+#  define BOOST_HAS_TR1_HASH
+#  define BOOST_HAS_TR1_SHARED_PTR
+#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 403
+#  define BOOST_HAS_TR1_RANDOM
+//#  define BOOST_HAS_TR1_REGEX
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#  define BOOST_HAS_TR1_CMATH
+#endif
+#endif
+#  define BOOST_HAS_TR1_TUPLE
+#  define BOOST_HAS_TR1_TYPE_TRAITS
+#  define BOOST_HAS_TR1_UTILITY
+#  define BOOST_HAS_TR1_UNORDERED_MAP
+#  define BOOST_HAS_TR1_UNORDERED_SET
+
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1500) \
+   && defined(_MSC_FULL_VER) && \
+   !defined(__SGI_STL_PORT) && \
+   !defined(_STLPORT_VERSION) && \
+   !defined(_RWSTD_VER_STR) && \
+   !defined(_RWSTD_VER)
+//
+// MSVC-9.0 defines a not-quite TR1 conforming hash
+// function object in <functional>, so we must define
+// this here, in addition the feature pack for VC9
+// provides a more or less full TR1 implementation:
+//
+#  if (defined(_HAS_TR1) && (_HAS_TR1 + 0)) || (_CPPLIB_VER >= 540)
+#    define BOOST_HAS_TR1_ARRAY
+#    define BOOST_HAS_TR1_REFERENCE_WRAPPER
+#    define BOOST_HAS_TR1_RESULT_OF
+#    define BOOST_HAS_TR1_MEM_FN
+#    define BOOST_HAS_TR1_BIND
+#    define BOOST_HAS_TR1_FUNCTION
+#    define BOOST_HAS_TR1_HASH
+#    define BOOST_HAS_TR1_SHARED_PTR
+#    define BOOST_HAS_TR1_RANDOM
+#    define BOOST_HAS_TR1_REGEX
+#    define BOOST_HAS_TR1_TUPLE
+#    define BOOST_HAS_TR1_TYPE_TRAITS
+#    define BOOST_HAS_TR1_UTILITY
+#    define BOOST_HAS_TR1_UNORDERED_MAP
+#    define BOOST_HAS_TR1_UNORDERED_SET
+#  else
+#    define BOOST_HAS_TR1_HASH
+#  endif
+#  if _MSC_VER >= 1600
+#     define BOOST_HAS_CPP_0X
+#  endif
+#  if _MSC_VER >= 1700 
+#     define BOOST_HAS_TR1_COMPLEX_OVERLOADS 
+#  endif 
+#endif
+
+#include <boost/config.hpp>
+
+#endif
+
+
+