diff --git a/src/thirdparty/boost_lib/boost/align.hpp b/src/thirdparty/boost_lib/boost/align.hpp new file mode 100644 index 000000000..4d6010060 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align.hpp @@ -0,0 +1,31 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_HPP +#define BOOST_ALIGN_HPP + +/** + Boost.Align + all headers. + + @note This header includes all public headers + of the Boost.Align library. + + @file + @author Glen Fernandes +*/ + +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/align.hpp b/src/thirdparty/boost_lib/boost/align/align.hpp new file mode 100644 index 000000000..8d29fca46 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/align.hpp @@ -0,0 +1,86 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGN_HPP +#define BOOST_ALIGN_ALIGN_HPP + +/** + Function align. + + @file + @author Glen Fernandes +*/ + +#include + +/** + @cond +*/ +#if !defined(BOOST_NO_CXX11_STD_ALIGN) +#include +#else +#include +#endif + +#if defined(BOOST_NO_CXX11_STD_ALIGN) +/** + @endcond +*/ + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + If it is possible to fit `size` bytes of storage + aligned by `alignment` into the buffer pointed to by + `ptr` with length `space`, the function updates `ptr` + to point to the first possible address of such + storage and decreases `space` by the number of bytes + used for alignment. Otherwise, the function does + nothing. + + @param alignment Shall be a fundamental alignment + value or an extended alignment value, and shall be + a power of two. + + @param size The size in bytes of storage to fit into + the buffer. + + @param ptr Shall point to contiguous storage of at + least `space` bytes. + + @param space The length of the buffer. + + @return A null pointer if the requested aligned + buffer would not fit into the available space, + otherwise the adjusted value of `ptr`. + + @remark **Note:** The function updates its `ptr` and + space arguments so that it can be called repeatedly + with possibly different `alignment` and `size` + arguments for the same buffer. + */ + inline void* align(std::size_t alignment, std::size_t size, + void*& ptr, std::size_t& space); + } +} + +/** + @cond +*/ +#endif +/** + @endcond +*/ + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_alloc.hpp b/src/thirdparty/boost_lib/boost/align/aligned_alloc.hpp new file mode 100644 index 000000000..07035b720 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_alloc.hpp @@ -0,0 +1,100 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_ALLOC_HPP +#define BOOST_ALIGN_ALIGNED_ALLOC_HPP + +/** + Functions aligned_alloc and aligned_free. + + @file + @author Glen Fernandes +*/ + +#include + +/** + @cond +*/ +#if defined(BOOST_HAS_UNISTD_H) +#include +#endif + +#if defined(__APPLE__) || defined(__APPLE_CC__) || defined(macintosh) +#include +#endif + +#if defined(_MSC_VER) +#include +#elif defined(__MINGW32__) && (__MSVCRT_VERSION__ >= 0x0700) +#include +#elif MAC_OS_X_VERSION_MIN_REQUIRED >= 1090 +#include +#elif MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 +#include +#elif defined(__ANDROID__) +#include +#elif defined(__SunOS_5_11) || defined(__SunOS_5_12) +#include +#elif defined(sun) || defined(__sun) +#include +#elif (_POSIX_C_SOURCE >= 200112L) || (_XOPEN_SOURCE >= 600) +#include +#else +#include +#endif +/** + @endcond +*/ + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + Allocates space for an object whose alignment is + specified by `alignment`, whose size is + specified by `size`, and whose value is + indeterminate. + + @param alignment Shall be a power of two. + + @param size Size of space to allocate. + + @return A null pointer or a pointer to the + allocated space. + + @remark **Note:** On certain platforms, the + alignment may be rounded up to `alignof(void*)` + and the space allocated may be slightly larger + than `size` bytes, by an additional + `sizeof(void*)` and `alignment - 1` bytes. + */ + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT; + + /** + Causes the space pointed to by `ptr` to be + deallocated, that is, made available for further + allocation. If `ptr` is a null pointer, no + action occurs. Otherwise, if the argument does + not match a pointer earlier returned by the + `aligned_alloc` function, or if the space has + been deallocated by a call to `aligned_free`, + the behavior is undefined. + */ + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_allocator.hpp b/src/thirdparty/boost_lib/boost/align/aligned_allocator.hpp new file mode 100644 index 000000000..03b254627 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_allocator.hpp @@ -0,0 +1,287 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP +#define BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP + +/** + Class template aligned_allocator. + + @file + @author Glen Fernandes +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#endif + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + Class template aligned_allocator. + + @tparam Alignment Is the minimum alignment to specify + for allocations, if it is larger than the alignment + of the value type. It shall be a power of two. + + @remark **Note:** Except for the destructor, member + functions of the aligned allocator shall not + introduce data races as a result of concurrent calls + to those member functions from different threads. + Calls to these functions that allocate or deallocate + a particular unit of storage shall occur in a single + total order, and each such deallocation call shall + happen before the next allocation (if any) in this + order. + + @note Specifying minimum alignment is generally only + suitable for containers such as vector and undesirable + with other, node-based, containers. For node-based + containers, such as list, the node object would have + the minimum alignment specified instead of the value + type object. + */ + template + class aligned_allocator { + /** + @cond + */ + BOOST_STATIC_ASSERT(detail:: + is_alignment_const::value); + /** + @endcond + */ + + public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef void* void_pointer; + typedef const void* const_void_pointer; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef T& reference; + typedef const T& const_reference; + + private: + enum { + TypeAlign = alignment_of::value, + + MaxAlign = detail:: + max_align::value + }; + + public: + /** + Rebind allocator. + */ + template + struct rebind { + typedef aligned_allocator other; + }; + +#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) + aligned_allocator() + BOOST_NOEXCEPT = default; +#else + aligned_allocator() + BOOST_NOEXCEPT { + } +#endif + + template + aligned_allocator(const aligned_allocator&) BOOST_NOEXCEPT { + } + + /** + @return The actual address of the object referenced + by `value`, even in the presence of an overloaded + operator&. + */ + pointer address(reference value) const + BOOST_NOEXCEPT { + return detail::addressof(value); + } + + /** + @return The actual address of the object referenced + by `value`, even in the presence of an overloaded + operator&. + */ + const_pointer address(const_reference value) const + BOOST_NOEXCEPT { + return detail::addressof(value); + } + + /** + @return A pointer to the initial element of an array + of storage of size `n * sizeof(T)`, aligned on the + maximum of the minimum alignment specified and the + alignment of objects of type `T`. + + @remark **Throw:** Throws `std::bad_alloc` if the + storage cannot be obtained. + + @remark **Note:** The storage is obtained by calling + `aligned_alloc(std::size_t, std::size_t)`. + */ + pointer allocate(size_type size, const_void_pointer = 0) { + void* p = aligned_alloc(MaxAlign, sizeof(T) * size); + if (!p && size > 0) { + boost::throw_exception(std::bad_alloc()); + } + return static_cast(p); + } + + /** + Deallocates the storage referenced by `ptr`. + + @param ptr Shall be a pointer value obtained from + `allocate()`. + + @remark **Note:** Uses + `alignment::aligned_free(void*)`. + */ + void deallocate(pointer ptr, size_type) { + alignment::aligned_free(ptr); + } + + /** + @return The largest value `N` for which the call + `allocate(N)` might succeed. + */ + BOOST_CONSTEXPR size_type max_size() const + BOOST_NOEXCEPT { + return detail::max_count_of::value; + } + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + /** + Calls global + `new((void*)ptr) U(std::forward(args)...)`. + */ + template + void construct(U* ptr, Args&&... args) { + void* p = ptr; + ::new(p) U(std::forward(args)...); + } +#else + /** + Calls global + `new((void*)ptr) U(std::forward(value))`. + */ + template + void construct(U* ptr, V&& value) { + void* p = ptr; + ::new(p) U(std::forward(value)); + } +#endif +#else + /** + Calls global `new((void*)ptr) U(value)`. + */ + template + void construct(U* ptr, const V& value) { + void* p = ptr; + ::new(p) U(value); + } +#endif + + /** + Calls global `new((void*)ptr) U()`. + */ + template + void construct(U* ptr) { + void* p = ptr; + ::new(p) U(); + } + + /** + Calls `ptr->~U()`. + */ + template + void destroy(U* ptr) { + (void)ptr; + ptr->~U(); + } + }; + + /** + Class template aligned_allocator + specialization. + */ + template + class aligned_allocator { + /** + @cond + */ + BOOST_STATIC_ASSERT(detail:: + is_alignment_const::value); + /** + @endcond + */ + + public: + typedef void value_type; + typedef void* pointer; + typedef const void* const_pointer; + + /** + Rebind allocator. + */ + template + struct rebind { + typedef aligned_allocator other; + }; + }; + + /** + @return `true`. + */ + template + inline bool operator==(const aligned_allocator&, const aligned_allocator&) BOOST_NOEXCEPT + { + return true; + } + + /** + @return `false`. + */ + template + inline bool operator!=(const aligned_allocator&, const aligned_allocator&) BOOST_NOEXCEPT + { + return false; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_allocator_adaptor.hpp b/src/thirdparty/boost_lib/boost/align/aligned_allocator_adaptor.hpp new file mode 100644 index 000000000..2083c949d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_allocator_adaptor.hpp @@ -0,0 +1,325 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_HPP +#define BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_HPP + +/** + Class template aligned_allocator_adaptor. + + @file + @author Glen Fernandes +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_ALLOCATOR) +#include +#endif + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#endif + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + Class template aligned_allocator_adaptor. + + @tparam Alignment Is the minimum alignment to specify + for allocations, if it is larger than the alignment + of the value type. The value of `Alignment` shall be + a fundamental alignment value or an extended alignment + value, and shall be a power of two. + + @note This adaptor can be used with a C++11 allocator + whose pointer type is a smart pointer but the adaptor + will expose only raw pointers. + */ + template + class aligned_allocator_adaptor + : public Allocator { + /** + @cond + */ + BOOST_STATIC_ASSERT(detail:: + is_alignment_const::value); + /** + @endcond + */ + +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + /** + Exposition only. + */ + typedef std::allocator_traits Traits; + + typedef typename Traits:: + template rebind_alloc CharAlloc; + + typedef typename Traits:: + template rebind_traits CharTraits; + + typedef typename CharTraits::pointer CharPtr; +#else + typedef typename Allocator:: + template rebind::other CharAlloc; + + typedef typename CharAlloc::pointer CharPtr; +#endif + + public: +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef typename Traits::value_type value_type; + typedef typename Traits::size_type size_type; +#else + typedef typename Allocator::value_type value_type; + typedef typename Allocator::size_type size_type; +#endif + + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef void* void_pointer; + typedef const void* const_void_pointer; + typedef std::ptrdiff_t difference_type; + + private: + enum { + TypeAlign = alignment_of::value, + + PtrAlign = alignment_of::value, + + BlockAlign = detail:: + max_align::value, + + MaxAlign = detail:: + max_align::value + }; + + public: + /** + Rebind allocator. + */ + template + struct rebind { +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef aligned_allocator_adaptor, Alignment> other; +#else + typedef aligned_allocator_adaptor::other, Alignment> other; +#endif + }; + +#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) + /** + Value-initializes the `Allocator` + base class. + */ + aligned_allocator_adaptor() = default; +#else + /** + Value-initializes the `Allocator` + base class. + */ + aligned_allocator_adaptor() + : Allocator() { + } +#endif + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + /** + Initializes the `Allocator` base class with + `std::forward(alloc)`. + + @remark **Require:** `Allocator` shall be + constructible from `A`. + */ + template + explicit aligned_allocator_adaptor(A&& alloc) + BOOST_NOEXCEPT + : Allocator(std::forward(alloc)) { + } +#else + /** + Initializes the `Allocator` base class with + `alloc`. + + @remark **Require:** `Allocator` shall be + constructible from `A`. + */ + template + explicit aligned_allocator_adaptor(const A& alloc) + BOOST_NOEXCEPT + : Allocator(alloc) { + } +#endif + + /** + Initializes the `Allocator` base class with the + base from other. + */ + template + aligned_allocator_adaptor(const + aligned_allocator_adaptor& other) + BOOST_NOEXCEPT + : Allocator(other.base()) { + } + + /** + @return `static_cast(*this)`. + */ + Allocator& base() + BOOST_NOEXCEPT { + return static_cast(*this); + } + + /** + @return `static_cast(*this)`. + */ + const Allocator& base() const + BOOST_NOEXCEPT { + return static_cast(*this); + } + + /** + @param size The size of the value type object to + allocate. + + @return A pointer to the initial element of an + array of storage of size `n * sizeof(value_type)`, + aligned on the maximum of the minimum alignment + specified and the alignment of objects of type + `value_type`. + + @remark **Throw:** Throws an exception thrown from + `A2::allocate` if the storage cannot be obtained. + + @remark **Note:** The storage is obtained by calling + `A2::allocate` on an object `a2`, where `a2` of + type `A2` is a rebound copy of `base()` where its + `value_type` is unspecified. + */ + pointer allocate(size_type size) { + std::size_t n1 = size * sizeof(value_type); + std::size_t n2 = n1 + MaxAlign - 1; + CharAlloc a(base()); + CharPtr p1 = a.allocate(sizeof p1 + n2); + void* p2 = detail::addressof(*p1) + sizeof p1; + (void)align(MaxAlign, n1, p2, n2); + void* p3 = static_cast(p2) - 1; + ::new(p3) CharPtr(p1); + return static_cast(p2); + } + + /** + @param hint is a value obtained by calling + `allocate()` on any equivalent aligned allocator + adaptor object, or else `nullptr`. + + @param size The size of the value type object to + allocate. + + @return A pointer to the initial element of an + array of storage of size `n * sizeof(value_type)`, + aligned on the maximum of the minimum alignment + specified and the alignment of objects of type + `value_type`. + + @remark **Throw:** Throws an exception thrown from + `A2::allocate` if the storage cannot be obtained. + + @remark **Note:** The storage is obtained by calling + `A2::allocate` on an object `a2`, where `a2` of + type `A2` is a rebound copy of `base()` where its + `value_type` is unspecified. + */ + pointer allocate(size_type size, const_void_pointer hint) { + std::size_t n1 = size * sizeof(value_type); + std::size_t n2 = n1 + MaxAlign - 1; + CharPtr h = CharPtr(); + if (hint) { + h = *(static_cast(hint) - 1); + } + CharAlloc a(base()); +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + CharPtr p1 = CharTraits::allocate(a, sizeof p1 + + n2, h); +#else + CharPtr p1 = a.allocate(sizeof p1 + n2, h); +#endif + void* p2 = detail::addressof(*p1) + sizeof p1; + (void)align(MaxAlign, n1, p2, n2); + void* p3 = static_cast(p2) - 1; + ::new(p3) CharPtr(p1); + return static_cast(p2); + } + + /** + Deallocates the storage referenced by `ptr`. + + @param ptr Shall be a pointer value obtained from + `allocate()`. + + @param size Shall equal the value passed as the + first argument to the invocation of `allocate` + which returned `ptr`. + + @remark **Note:** Uses `A2::deallocate` on an object + `a2`, where `a2` of type `A2` is a rebound copy of + `base()` where its `value_type` is unspecified. + */ + void deallocate(pointer ptr, size_type size) { + CharPtr* p1 = reinterpret_cast(ptr) - 1; + CharPtr p2 = *p1; + p1->~CharPtr(); + CharAlloc a(base()); + a.deallocate(p2, size * sizeof(value_type) + + MaxAlign + sizeof p2); + } + }; + + /** + @return `a.base() == b.base()`. + */ + template + inline bool operator==(const aligned_allocator_adaptor& a, const aligned_allocator_adaptor& b) BOOST_NOEXCEPT + { + return a.base() == b.base(); + } + + /** + @return `!(a == b)`. + */ + template + inline bool operator!=(const aligned_allocator_adaptor& a, const aligned_allocator_adaptor& b) BOOST_NOEXCEPT + { + return !(a == b); + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_allocator_adaptor_forward.hpp b/src/thirdparty/boost_lib/boost/align/aligned_allocator_adaptor_forward.hpp new file mode 100644 index 000000000..524e0676e --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_allocator_adaptor_forward.hpp @@ -0,0 +1,38 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_FORWARD_HPP +#define BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_FORWARD_HPP + +/** + Class template aligned_allocator_adaptor + forward declaration. + + @note This header provides a forward declaration for + the `aligned_allocator_adaptor` class template. + + @file + @author Glen Fernandes +*/ + +#include + +/** + @cond +*/ +namespace boost { + namespace alignment { + template + class aligned_allocator_adaptor; + } +} +/** + @endcond +*/ + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_allocator_forward.hpp b/src/thirdparty/boost_lib/boost/align/aligned_allocator_forward.hpp new file mode 100644 index 000000000..6f1542367 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_allocator_forward.hpp @@ -0,0 +1,38 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_FORWARD_HPP +#define BOOST_ALIGN_ALIGNED_ALLOCATOR_FORWARD_HPP + +/** + Class template aligned_allocator + forward declaration. + + @note This header provides a forward declaration + for the `aligned_allocator` class template. + + @file + @author Glen Fernandes +*/ + +#include + +/** + @cond +*/ +namespace boost { + namespace alignment { + template + class aligned_allocator; + } +} +/** + @endcond +*/ + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_delete.hpp b/src/thirdparty/boost_lib/boost/align/aligned_delete.hpp new file mode 100644 index 000000000..05ebb82f7 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_delete.hpp @@ -0,0 +1,56 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_DELETE_HPP +#define BOOST_ALIGN_ALIGNED_DELETE_HPP + +/** + Class aligned_delete. + + @file + @author Glen Fernandes +*/ + +#include +#include +#include + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + Class aligned_delete. + */ + class aligned_delete { + public: + /** + Calls `~T()` on `ptr` to destroy the object and then + calls `aligned_free` on `ptr` to free the allocated + memory. + + @remark **Note:** If `T` is an incomplete type, the + program is ill-formed. + */ + template + void operator()(T* ptr) const + BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(ptr->~T())) { + if (ptr) { + ptr->~T(); + alignment::aligned_free(ptr); + } + } + }; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/aligned_delete_forward.hpp b/src/thirdparty/boost_lib/boost/align/aligned_delete_forward.hpp new file mode 100644 index 000000000..efa882274 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/aligned_delete_forward.hpp @@ -0,0 +1,35 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNED_DELETE_FORWARD_HPP +#define BOOST_ALIGN_ALIGNED_DELETE_FORWARD_HPP + +/** + Class aligned_delete + forward declaration. + + @note This header provides a forward declaration + for the `aligned_delete` class. + + @file + @author Glen Fernandes +*/ + +/** + @cond +*/ +namespace boost { + namespace alignment { + class aligned_delete; + } +} +/** + @endcond +*/ + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/alignment_of.hpp b/src/thirdparty/boost_lib/boost/align/alignment_of.hpp new file mode 100644 index 000000000..ebd87aab9 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/alignment_of.hpp @@ -0,0 +1,78 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNMENT_OF_HPP +#define BOOST_ALIGN_ALIGNMENT_OF_HPP + +/** + Class template alignment_of. + + @file + @author Glen Fernandes +*/ + +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) +#include +#elif defined(BOOST_MSVC) +#include +#elif defined(BOOST_CLANG) +#include +#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) +#include +#elif defined(__CODEGEARC__) +#include +#elif defined(__GNUC__) && defined(__unix__) && !defined(__LP64__) +#include +#elif __GNUC__ > 4 +#include +#elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) +#include +#else +#include +#endif + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + Class template alignment_of. + + @remark **Value:** `alignof(T)`. + */ + template + struct alignment_of { + /** + @enum + */ + enum { + /** + @cond + */ + value = detail::alignment_of:: + type>::type>::type>::value + /** + @endcond + */ + }; + }; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/alignment_of_forward.hpp b/src/thirdparty/boost_lib/boost/align/alignment_of_forward.hpp new file mode 100644 index 000000000..2abd08386 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/alignment_of_forward.hpp @@ -0,0 +1,36 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP +#define BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP + +/** + Class template alignment_of + forward declaration. + + @note This header provides a forward declaration + for the `alignment_of` class template. + + @file + @author Glen Fernandes +*/ + +/** + @cond +*/ +namespace boost { + namespace alignment { + template + struct alignment_of; + } +} +/** + @endcond +*/ + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/address.hpp b/src/thirdparty/boost_lib/boost/align/detail/address.hpp new file mode 100644 index 000000000..a205cbd17 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/address.hpp @@ -0,0 +1,27 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ADDRESS_HPP +#define BOOST_ALIGN_DETAIL_ADDRESS_HPP + +#include +#include + +namespace boost { + namespace alignment { + namespace detail { +#if defined(BOOST_HAS_INTPTR_T) + typedef boost::uintptr_t address_t; +#else + typedef std::size_t address_t; +#endif + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/addressof.hpp b/src/thirdparty/boost_lib/boost/align/detail/addressof.hpp new file mode 100644 index 000000000..1b9402f32 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/addressof.hpp @@ -0,0 +1,32 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ADDRESSOF_HPP +#define BOOST_ALIGN_DETAIL_ADDRESSOF_HPP + +#include + +#if !defined(BOOST_NO_CXX11_ADDRESSOF) +#include +#else +#include +#endif + +namespace boost { + namespace alignment { + namespace detail { +#if !defined(BOOST_NO_CXX11_ADDRESSOF) + using std::addressof; +#else + using boost::addressof; +#endif + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/align.hpp b/src/thirdparty/boost_lib/boost/align/detail/align.hpp new file mode 100644 index 000000000..d4d4287c5 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/align.hpp @@ -0,0 +1,38 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGN_HPP +#define BOOST_ALIGN_DETAIL_ALIGN_HPP + +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* align(std::size_t alignment, std::size_t size, + void*& ptr, std::size_t& space) + { + BOOST_ASSERT(detail::is_alignment(alignment)); + std::size_t n = detail::address_t(ptr) & (alignment - 1); + if (n != 0) { + n = alignment - n; + } + void* p = 0; + if (n <= space && size <= space - n) { + p = static_cast(ptr) + n; + ptr = p; + space -= n; + } + return p; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/align_cxx11.hpp b/src/thirdparty/boost_lib/boost/align/detail/align_cxx11.hpp new file mode 100644 index 000000000..b79ea8e8c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/align_cxx11.hpp @@ -0,0 +1,20 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP +#define BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP + +#include + +namespace boost { + namespace alignment { + using std::align; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc.hpp b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc.hpp new file mode 100644 index 000000000..3ed58b5d2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc.hpp @@ -0,0 +1,53 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP +#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + enum { + void_align = alignment_of::value, + }; + if (alignment < void_align) { + alignment = void_align; + } + std::size_t n = size + alignment - 1; + void* p1 = 0; + void* p2 = std::malloc(n + sizeof p1); + if (p2) { + p1 = static_cast(p2) + sizeof p1; + (void)align(alignment, size, p1, n); + *(static_cast(p1) - 1) = p2; + } + return p1; + } + + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT + { + if (ptr) { + void* p = *(static_cast(ptr) - 1); + std::free(p); + } + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_android.hpp b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_android.hpp new file mode 100644 index 000000000..bad569a9c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_android.hpp @@ -0,0 +1,35 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP +#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + return ::memalign(alignment, size); + } + + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT + { + ::free(ptr); + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_macos.hpp b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_macos.hpp new file mode 100644 index 000000000..99ce60d3d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_macos.hpp @@ -0,0 +1,48 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP +#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + enum { + void_size = sizeof(void*) + }; + if (!size) { + return 0; + } + if (alignment < void_size) { + alignment = void_size; + } + void* p; + if (::posix_memalign(&p, alignment, size) != 0) { + p = 0; + } + return p; + } + + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT + { + ::free(ptr); + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_msvc.hpp b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_msvc.hpp new file mode 100644 index 000000000..93ed594f0 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_msvc.hpp @@ -0,0 +1,35 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP +#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + return ::_aligned_malloc(size, alignment); + } + + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT + { + ::_aligned_free(ptr); + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_posix.hpp b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_posix.hpp new file mode 100644 index 000000000..3663030a1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_posix.hpp @@ -0,0 +1,45 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP +#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + enum { + void_size = sizeof(void*) + }; + if (alignment < void_size) { + alignment = void_size; + } + void* p; + if (::posix_memalign(&p, alignment, size) != 0) { + p = 0; + } + return p; + } + + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT + { + ::free(ptr); + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_sunos.hpp b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_sunos.hpp new file mode 100644 index 000000000..aebf1801f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/aligned_alloc_sunos.hpp @@ -0,0 +1,35 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP +#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline void* aligned_alloc(std::size_t alignment, + std::size_t size) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + return ::memalign(alignment, size); + } + + inline void aligned_free(void* ptr) + BOOST_NOEXCEPT + { + ::free(ptr); + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/alignment_of.hpp b/src/thirdparty/boost_lib/boost/align/detail/alignment_of.hpp new file mode 100644 index 000000000..44745addd --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/alignment_of.hpp @@ -0,0 +1,29 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP +#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP + +#include +#include + +namespace boost { + namespace alignment { + namespace detail { + template + struct alignment_of { + enum { + value = detail::min_size) - sizeof(T)>::value + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/alignment_of_clang.hpp b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_clang.hpp new file mode 100644 index 000000000..526ff7b58 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_clang.hpp @@ -0,0 +1,25 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP +#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP + +namespace boost { + namespace alignment { + namespace detail { + template + struct alignment_of { + enum { + value = __alignof(T) + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/alignment_of_codegear.hpp b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_codegear.hpp new file mode 100644 index 000000000..2af47e91d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_codegear.hpp @@ -0,0 +1,25 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP +#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP + +namespace boost { + namespace alignment { + namespace detail { + template + struct alignment_of { + enum { + value = alignof(T) + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/alignment_of_cxx11.hpp b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_cxx11.hpp new file mode 100644 index 000000000..16327c6f7 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_cxx11.hpp @@ -0,0 +1,22 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP +#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP + +#include + +namespace boost { + namespace alignment { + namespace detail { + using std::alignment_of; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/alignment_of_gcc.hpp b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_gcc.hpp new file mode 100644 index 000000000..426dbba5e --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_gcc.hpp @@ -0,0 +1,25 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP +#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP + +namespace boost { + namespace alignment { + namespace detail { + template + struct alignment_of { + enum { + value = __alignof__(T) + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/alignment_of_msvc.hpp b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_msvc.hpp new file mode 100644 index 000000000..fcf2b7dba --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/alignment_of_msvc.hpp @@ -0,0 +1,30 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP +#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP + +#include +#include +#include + +namespace boost { + namespace alignment { + namespace detail { + template + struct alignment_of { + enum { + value = detail::min_size, object)>::value + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/is_aligned.hpp b/src/thirdparty/boost_lib/boost/align/detail/is_aligned.hpp new file mode 100644 index 000000000..a017e6b83 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/is_aligned.hpp @@ -0,0 +1,29 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNED_HPP +#define BOOST_ALIGN_DETAIL_IS_ALIGNED_HPP + +#include +#include +#include +#include +#include + +namespace boost { + namespace alignment { + inline bool is_aligned(std::size_t alignment, + const void* ptr) BOOST_NOEXCEPT + { + BOOST_ASSERT(detail::is_alignment(alignment)); + return (detail::address_t(ptr) & (alignment - 1)) == 0; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/is_alignment.hpp b/src/thirdparty/boost_lib/boost/align/detail/is_alignment.hpp new file mode 100644 index 000000000..6e34cacb8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/is_alignment.hpp @@ -0,0 +1,27 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP +#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP + +#include +#include + +namespace boost { + namespace alignment { + namespace detail { + BOOST_CONSTEXPR inline bool is_alignment(std::size_t + value) BOOST_NOEXCEPT + { + return (value > 0) && ((value & (value - 1)) == 0); + } + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/is_alignment_const.hpp b/src/thirdparty/boost_lib/boost/align/detail/is_alignment_const.hpp new file mode 100644 index 000000000..f6d7e9740 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/is_alignment_const.hpp @@ -0,0 +1,27 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_CONST_HPP +#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_CONST_HPP + +#include + +namespace boost { + namespace alignment { + namespace detail { + template + struct is_alignment_const { + enum { + value = (N > 0) && ((N & (N - 1)) == 0) + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/max_align.hpp b/src/thirdparty/boost_lib/boost/align/detail/max_align.hpp new file mode 100644 index 000000000..8e64e7bb9 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/max_align.hpp @@ -0,0 +1,27 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_MAX_ALIGN_HPP +#define BOOST_ALIGN_DETAIL_MAX_ALIGN_HPP + +#include + +namespace boost { + namespace alignment { + namespace detail { + template + struct max_align { + enum { + value = (A > B) ? A : B + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/max_count_of.hpp b/src/thirdparty/boost_lib/boost/align/detail/max_count_of.hpp new file mode 100644 index 000000000..62917ac1f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/max_count_of.hpp @@ -0,0 +1,27 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_MAX_COUNT_OF_HPP +#define BOOST_ALIGN_DETAIL_MAX_COUNT_OF_HPP + +#include + +namespace boost { + namespace alignment { + namespace detail { + template + struct max_count_of { + enum { + value = ~static_cast(0) / sizeof(T) + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/min_size.hpp b/src/thirdparty/boost_lib/boost/align/detail/min_size.hpp new file mode 100644 index 000000000..20e31fb4b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/min_size.hpp @@ -0,0 +1,27 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_MIN_SIZE_HPP +#define BOOST_ALIGN_DETAIL_MIN_SIZE_HPP + +#include + +namespace boost { + namespace alignment { + namespace detail { + template + struct min_size { + enum { + value = (A < B) ? A : B + }; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/padded.hpp b/src/thirdparty/boost_lib/boost/align/detail/padded.hpp new file mode 100644 index 000000000..9aeeee892 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/padded.hpp @@ -0,0 +1,24 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_PADDED_HPP +#define BOOST_ALIGN_DETAIL_PADDED_HPP + +namespace boost { + namespace alignment { + namespace detail { + template + struct padded { + char unit; + T object; + }; + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/detail/type_traits.hpp b/src/thirdparty/boost_lib/boost/align/detail/type_traits.hpp new file mode 100644 index 000000000..b250f18a2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/detail/type_traits.hpp @@ -0,0 +1,90 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_DETAIL_TYPE_TRAITS_HPP +#define BOOST_ALIGN_DETAIL_TYPE_TRAITS_HPP + +#include + +#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) +#include +#else +#include +#endif + +namespace boost { + namespace alignment { + namespace detail { +#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) + using std::remove_reference; + using std::remove_all_extents; + using std::remove_cv; +#else + template + struct remove_reference { + typedef T type; + }; + + template + struct remove_reference { + typedef T type; + }; + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + template + struct remove_reference { + typedef T type; + }; +#endif + + template + struct remove_all_extents { + typedef T type; + }; + + template + struct remove_all_extents { + typedef typename remove_all_extents::type type; + }; + + template + struct remove_all_extents { + typedef typename remove_all_extents::type type; + }; + + template + struct remove_const { + typedef T type; + }; + + template + struct remove_const { + typedef T type; + }; + + template + struct remove_volatile { + typedef T type; + }; + + template + struct remove_volatile { + typedef T type; + }; + + template + struct remove_cv { + typedef typename remove_volatile::type>::type type; + }; +#endif + } + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/align/is_aligned.hpp b/src/thirdparty/boost_lib/boost/align/is_aligned.hpp new file mode 100644 index 000000000..d59bf8d9b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/align/is_aligned.hpp @@ -0,0 +1,53 @@ +/* + Copyright (c) 2014 Glen Joseph Fernandes + glenfe at live dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_ALIGN_IS_ALIGNED_HPP +#define BOOST_ALIGN_IS_ALIGNED_HPP + +/** + Function is_aligned. + + @file + @author Glen Fernandes +*/ + +/** + @cond +*/ +#include +/** + @endcond +*/ + +/** + Boost namespace. +*/ +namespace boost { + /** + Alignment namespace. + */ + namespace alignment { + /** + Determines whether the space pointed to by + `ptr` has alignment specified by + `alignment`. + + @param alignment Shall be a power of two. + + @param ptr Pointer to test for alignment. + + @return `true` if and only if `ptr` points + to space that has alignment specified by + `alignment`. + */ + inline bool is_aligned(std::size_t alignment, + const void* ptr) BOOST_NOEXCEPT; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/aligned_storage.hpp b/src/thirdparty/boost_lib/boost/aligned_storage.hpp index ce277ab70..b5455f00b 100644 --- a/src/thirdparty/boost_lib/boost/aligned_storage.hpp +++ b/src/thirdparty/boost_lib/boost/aligned_storage.hpp @@ -48,10 +48,10 @@ struct aligned_storage_imp { char buf[size_]; - typename mpl::eval_if_c< + typename ::boost::mpl::eval_if_c< alignment_ == std::size_t(-1) - , mpl::identity - , type_with_alignment + , ::boost::mpl::identity< ::boost::detail::max_align > + , ::boost::type_with_alignment >::type align_; } data_; void* address() const { return const_cast(this); } @@ -76,12 +76,12 @@ class aligned_storage : #else public #endif - detail::aligned_storage::aligned_storage_imp + ::boost::detail::aligned_storage::aligned_storage_imp { public: // constants - typedef detail::aligned_storage::aligned_storage_imp type; + typedef ::boost::detail::aligned_storage::aligned_storage_imp type; BOOST_STATIC_CONSTANT( std::size_t @@ -96,25 +96,11 @@ class aligned_storage : ) ); -#if defined(__GNUC__) &&\ - (__GNUC__ > 3) ||\ - (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 ||\ - (__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >=3))) - private: // noncopyable aligned_storage(const aligned_storage&); aligned_storage& operator=(const aligned_storage&); -#else // gcc less than 3.2.3 - -public: // _should_ be noncopyable, but GCC compiler emits error - - aligned_storage(const aligned_storage&); - aligned_storage& operator=(const aligned_storage&); - -#endif // gcc < 3.2.3 workaround - public: // structors aligned_storage() @@ -132,46 +118,22 @@ class aligned_storage : return static_cast(this)->address(); } -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - const void* address() const { return static_cast(this)->address(); } - -#else // MSVC6 - - const void* address() const; - -#endif // MSVC6 workaround - }; -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -// MSVC6 seems not to like inline functions with const void* returns, so we -// declare the following here: - -template -const void* aligned_storage::address() const -{ - return const_cast< aligned_storage* >(this)->address(); -} - -#endif // MSVC6 workaround - -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // // Make sure that is_pod recognises aligned_storage<>::type // as a POD (Note that aligned_storage<> itself is not a POD): // template -struct is_pod > +struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp > BOOST_TT_AUX_BOOL_C_BASE(true) { BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true) }; -#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/any.hpp b/src/thirdparty/boost_lib/boost/any.hpp index 771393530..a63fea42a 100644 --- a/src/thirdparty/boost_lib/boost/any.hpp +++ b/src/thirdparty/boost_lib/boost/any.hpp @@ -3,7 +3,7 @@ #ifndef BOOST_ANY_INCLUDED #define BOOST_ANY_INCLUDED -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -31,7 +31,7 @@ // See boost/python/type_id.hpp // TODO: add BOOST_TYPEID_COMPARE_BY_NAME to config.hpp -# if (defined(__GNUC__) && __GNUC__ >= 3) \ +# if defined(__GNUC__) \ || defined(_AIX) \ || ( defined(__sgi) && defined(__host_mips)) \ || (defined(__hpux) && defined(__HP_aCC)) \ @@ -40,11 +40,6 @@ #include # endif -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable: 4172) // Mistakenly warns: returning address of local variable or temporary -#endif - namespace boost { class any @@ -271,15 +266,6 @@ namespace boost { typedef BOOST_DEDUCED_TYPENAME remove_reference::type nonref; -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - // If 'nonref' is still reference type, it means the user has not - // specialized 'remove_reference'. - - // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro - // to generate specialization of remove_reference for your class - // See type traits library documentation for details - BOOST_STATIC_ASSERT(!is_reference::value); -#endif nonref * result = any_cast(&operand); if(!result) @@ -302,26 +288,19 @@ namespace boost inline ValueType any_cast(const any & operand) { typedef BOOST_DEDUCED_TYPENAME remove_reference::type nonref; - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - // The comment in the above version of 'any_cast' explains when this - // assert is fired and what to do. - BOOST_STATIC_ASSERT(!is_reference::value); -#endif - return any_cast(const_cast(operand)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template - inline ValueType&& any_cast(any&& operand) + inline ValueType any_cast(any&& operand) { BOOST_STATIC_ASSERT_MSG( - boost::is_rvalue_reference::value + boost::is_rvalue_reference::value /*true if ValueType is rvalue or just a value*/ || boost::is_const< typename boost::remove_reference::type >::value, "boost::any_cast shall not be used for getting nonconst references to temporary objects" ); - return any_cast(operand); + return any_cast(operand); } #endif @@ -350,8 +329,4 @@ namespace boost // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#if defined(_MSC_VER) -#pragma warning(pop) -#endif - #endif diff --git a/src/thirdparty/boost_lib/boost/archive/add_facet.hpp b/src/thirdparty/boost_lib/boost/archive/add_facet.hpp index 6bafe9bdb..242bdd900 100644 --- a/src/thirdparty/boost_lib/boost/archive/add_facet.hpp +++ b/src/thirdparty/boost_lib/boost/archive/add_facet.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ADD_FACET_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/archive_exception.hpp b/src/thirdparty/boost_lib/boost/archive/archive_exception.hpp index e27807bc2..ffb430c6a 100644 --- a/src/thirdparty/boost_lib/boost/archive/archive_exception.hpp +++ b/src/thirdparty/boost_lib/boost/archive/archive_exception.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -49,7 +49,7 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : typedef enum { no_exception, // initialized without code other_exception, // any excepton not listed below - unregistered_class, // attempt to serialize a pointer of an + unregistered_class, // attempt to serialize a pointer of // an unregistered class invalid_signature, // first line of archive does not contain // expected string @@ -57,8 +57,8 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : // subsequent to this one pointer_conflict, // an attempt has been made to directly // serialize an object which has - // already been serialzed through a pointer. - // Were this permited, the archive load would result + // already been serialized through a pointer. + // Were this permitted, the archive load would result // in the creation of an extra copy of the obect. incompatible_native_format, // attempt to read native binary format // on incompatible platform @@ -70,7 +70,7 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : unregistered_cast, // base - derived relationship not registered with // void_cast_register unsupported_class_version, // type saved with a version # greater than the - // one used by the program. This indicates that the proggram + // one used by the program. This indicates that the program // needs to be rebuilt. multiple_code_instantiation, // code for implementing serialization for some // type has been instantiated in more than one module. diff --git a/src/thirdparty/boost_lib/boost/archive/basic_archive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_archive.hpp index c5ac8808e..041211235 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_archive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_archive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -15,7 +15,7 @@ // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. - +#include // count #include #include #include // size_t @@ -221,6 +221,9 @@ struct class_name_type : operator char * () { return t; } + std::size_t size() const { + return std::strlen(t); + } explicit class_name_type(const char *key_) : t(const_cast(key_)){} explicit class_name_type(char *key_) diff --git a/src/thirdparty/boost_lib/boost/archive/basic_binary_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_binary_iarchive.hpp index d851dab4d..a649d5e91 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_binary_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_binary_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -44,21 +44,27 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class basic_binary_iarchive - read serialized objects from a input binary stream template class basic_binary_iarchive : public detail::common_iarchive { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_iarchive; #else - friend class detail::interface_iarchive; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + #else + friend class detail::interface_iarchive; + #endif #endif // intermediate level to support override of operators // fot templates in the absence of partial function diff --git a/src/thirdparty/boost_lib/boost/archive/basic_binary_iprimitive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_binary_iprimitive.hpp index fc27123de..2e72a1c6f 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_binary_iprimitive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_binary_iprimitive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -126,7 +126,7 @@ class basic_binary_iprimitive template #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS) struct apply { - typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type; + typedef typename boost::serialization::is_bitwise_serializable< T >::type type; }; #else struct apply : public boost::serialization::is_bitwise_serializable< T > {}; @@ -178,7 +178,7 @@ basic_binary_iprimitive::load_binary( boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); - std::memcpy(static_cast(address) + (count - s), &t, s); + std::memcpy(static_cast(address) + (count - s), &t, static_cast(s)); } } diff --git a/src/thirdparty/boost_lib/boost/archive/basic_binary_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_binary_oarchive.hpp index 01622b9f3..f8b53e9d7 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_binary_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_binary_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -46,6 +46,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + ////////////////////////////////////////////////////////////////////// // class basic_binary_oarchive - write serialized objects to a binary output stream // note: this archive has no pretensions to portability. Archive format @@ -58,15 +62,17 @@ template class basic_binary_oarchive : public archive::detail::common_oarchive { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_oarchive; #else - friend class detail::interface_oarchive; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + #else + friend class detail::interface_oarchive; + #endif #endif // any datatype not specifed below will be handled by base class typedef detail::common_oarchive detail_common_oarchive; diff --git a/src/thirdparty/boost_lib/boost/archive/basic_binary_oprimitive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_binary_oprimitive.hpp index 53e44e4fa..ba070cd39 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_binary_oprimitive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_binary_oprimitive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -58,8 +58,7 @@ namespace archive { // class basic_binary_oprimitive - binary output of prmitives template -class basic_binary_oprimitive -{ +class basic_binary_oprimitive { #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS friend class save_access; protected: @@ -122,7 +121,7 @@ class basic_binary_oprimitive template #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS) struct apply { - typedef BOOST_DEDUCED_TYPENAME boost::serialization::is_bitwise_serializable< T >::type type; + typedef typename boost::serialization::is_bitwise_serializable< T >::type type; }; #else struct apply : public boost::serialization::is_bitwise_serializable< T > {}; @@ -170,7 +169,7 @@ basic_binary_oprimitive::save_binary( archive_exception(archive_exception::output_stream_error) ); //os.write( - // static_cast(address), + // static_cast(address), // count //); //BOOST_ASSERT(os.good()); diff --git a/src/thirdparty/boost_lib/boost/archive/basic_streambuf_locale_saver.hpp b/src/thirdparty/boost_lib/boost/archive/basic_streambuf_locale_saver.hpp index ca764e104..6bf8f715c 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_streambuf_locale_saver.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_streambuf_locale_saver.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -50,7 +50,7 @@ class basic_streambuf_locale_saver : explicit basic_streambuf_locale_saver( state_type &s ) : s_save_( s ), a_save_( s.getloc() ) {} - basic_streambuf_locale_saver( state_type &s, aspect_type const &a ) + explicit basic_streambuf_locale_saver( state_type &s, aspect_type const &a ) : s_save_( s ), a_save_( s.pubimbue(a) ) {} ~basic_streambuf_locale_saver() diff --git a/src/thirdparty/boost_lib/boost/archive/basic_text_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_text_iarchive.hpp index 729d51aad..0e78ff6d1 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_text_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_text_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -40,21 +40,27 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class basic_text_iarchive - read serialized objects from a input text stream template class basic_text_iarchive : public detail::common_iarchive { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_iarchive; #else - friend class detail::interface_iarchive; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + #else + friend class detail::interface_iarchive; + #endif #endif // intermediate level to support override of operators // fot templates in the absence of partial function diff --git a/src/thirdparty/boost_lib/boost/archive/basic_text_iprimitive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_text_iprimitive.hpp index b927ec91a..dabc3c871 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_text_iprimitive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_text_iprimitive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -64,13 +64,8 @@ namespace archive { #endif template -class basic_text_iprimitive -{ -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +class basic_text_iprimitive { protected: -#else -public: -#endif IStream &is; io::ios_flags_saver flags_saver; io::ios_precision_saver precision_saver; @@ -78,18 +73,16 @@ class basic_text_iprimitive #ifndef BOOST_NO_STD_LOCALE boost::scoped_ptr archive_locale; basic_streambuf_locale_saver< - BOOST_DEDUCED_TYPENAME IStream::char_type, - BOOST_DEDUCED_TYPENAME IStream::traits_type + typename IStream::char_type, + typename IStream::traits_type > locale_saver; #endif template void load(T & t) { - if(! is.fail()){ - is >> t; + if(is >> t) return; - } boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); diff --git a/src/thirdparty/boost_lib/boost/archive/basic_text_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_text_oarchive.hpp index dd10f6598..bed9cd34d 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_text_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_text_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -42,23 +42,29 @@ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class basic_text_oarchive template class basic_text_oarchive : public detail::common_oarchive { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ -|| BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560)) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_oarchive; #else - friend class detail::interface_oarchive; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + #else + friend class detail::interface_oarchive; + #endif #endif + enum { none, eol, diff --git a/src/thirdparty/boost_lib/boost/archive/basic_text_oprimitive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_text_oprimitive.hpp index 06885ad35..73a0a62e5 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_text_oprimitive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_text_oprimitive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -26,13 +26,14 @@ #include #include -#include // isnan #include #include // size_t #include #include #include +#include + #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) #include #endif @@ -46,6 +47,8 @@ namespace std{ } // namespace std #endif +#include +#include #include #include #include @@ -65,11 +68,7 @@ class save_access; template class basic_text_oprimitive { -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS protected: -#else -public: -#endif OStream &os; io::ios_flags_saver flags_saver; io::ios_precision_saver precision_saver; @@ -77,21 +76,11 @@ class basic_text_oprimitive #ifndef BOOST_NO_STD_LOCALE boost::scoped_ptr archive_locale; basic_streambuf_locale_saver< - BOOST_DEDUCED_TYPENAME OStream::char_type, - BOOST_DEDUCED_TYPENAME OStream::traits_type + typename OStream::char_type, + typename OStream::traits_type > locale_saver; #endif - // default saving of primitives. - template - void save(const T &t){ - if(os.fail()) - boost::serialization::throw_exception( - archive_exception(archive_exception::output_stream_error) - ); - os << t; - } - ///////////////////////////////////////////////////////// // fundamental types that need special treatment void save(const bool t){ @@ -123,33 +112,77 @@ class basic_text_oprimitive save(static_cast(t)); } #endif - void save(const float t) - { - // must be a user mistake - can't serialize un-initialized data + + ///////////////////////////////////////////////////////// + // saving of any types not listed above + + template + void save_impl(const T &t, boost::mpl::bool_ &){ if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); - os << std::setprecision(std::numeric_limits::digits10 + 2); os << t; } - void save(const double t) - { + + ///////////////////////////////////////////////////////// + // floating point types need even more special treatment + // the following determines whether the type T is some sort + // of floating point type. Note that we then assume that + // the stream << operator is defined on that type - if not + // we'll get a compile time error. This is meant to automatically + // support synthesized types which support floating point + // operations. Also it should handle compiler dependent types + // such long double. Due to John Maddock. + + template + struct is_float { + typedef typename mpl::bool_< + boost::is_floating_point::value + || (std::numeric_limits::is_specialized + && !std::numeric_limits::is_integer + && !std::numeric_limits::is_exact + && std::numeric_limits::max_exponent) + >::type type; + }; + + template + void save_impl(const T &t, boost::mpl::bool_ &){ // must be a user mistake - can't serialize un-initialized data if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); - os << std::setprecision(std::numeric_limits::digits10 + 2); - os << t; + // The formulae for the number of decimla digits required is given in + // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf + // which is derived from Kahan's paper: + // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps + // const unsigned int digits = (std::numeric_limits::digits * 3010) / 10000; + // note: I've commented out the above because I didn't get good results. e.g. + // in one case I got a difference of 19 units. + #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS + const unsigned int digits = std::numeric_limits::max_digits10; + #else + const unsigned int digits = std::numeric_limits::digits10 + 2; + #endif + os << std::setprecision(digits) << std::scientific << t; } + + template + void save(const T & t){ + boost::io::ios_flags_saver fs(os); + boost::io::ios_precision_saver ps(os); + typename is_float::type tf; + save_impl(t, tf); + } + BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_oprimitive(OStream & os, bool no_codecvt); BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) ~basic_text_oprimitive(); public: // unformatted append of one character - void put(BOOST_DEDUCED_TYPENAME OStream::char_type c){ + void put(typename OStream::char_type c){ if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) diff --git a/src/thirdparty/boost_lib/boost/archive/basic_xml_archive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_xml_archive.hpp index c99d94fa6..a4ad3a2f0 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_xml_archive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_xml_archive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/basic_xml_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_xml_iarchive.hpp index d7b8bfd0c..5047fef26 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_xml_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_xml_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -37,21 +37,27 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + ///////////////////////////////////////////////////////////////////////// // class xml_iarchive - read serialized objects from a input text stream template class basic_xml_iarchive : public detail::common_iarchive { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) - // for some inexplicable reason insertion of "class" generates compile erro - // on msvc 7.1 - friend detail::interface_oarchive; #else - friend class detail::interface_oarchive; +protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + #else + friend class detail::interface_iarchive; + #endif #endif unsigned int depth; BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) diff --git a/src/thirdparty/boost_lib/boost/archive/basic_xml_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/basic_xml_oarchive.hpp index b571372ca..c986833c2 100644 --- a/src/thirdparty/boost_lib/boost/archive/basic_xml_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/basic_xml_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -36,24 +36,29 @@ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + ////////////////////////////////////////////////////////////////////// // class basic_xml_oarchive - write serialized objects to a xml output stream template class basic_xml_oarchive : public detail::common_oarchive { -protected: -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: -#elif defined(BOOST_MSVC) +#else +protected: +#endif +#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) // for some inexplicable reason insertion of "class" generates compile erro // on msvc 7.1 friend detail::interface_oarchive; - friend class save_access; #else friend class detail::interface_oarchive; - friend class save_access; #endif + friend class save_access; // special stuff for xml output unsigned int depth; bool indent_next; diff --git a/src/thirdparty/boost_lib/boost/archive/binary_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/binary_iarchive.hpp index 638d99672..ce67ccabd 100644 --- a/src/thirdparty/boost_lib/boost/archive/binary_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/binary_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -25,44 +25,7 @@ # pragma warning(disable : 4511 4512) #endif -namespace boost { -namespace archive { - -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as binary_iarchive below - without the shared_ptr_helper -class naked_binary_iarchive : - public binary_iarchive_impl< - boost::archive::naked_binary_iarchive, - std::istream::char_type, - std::istream::traits_type - > -{ -public: - naked_binary_iarchive(std::istream & is, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_iarchive, std::istream::char_type, std::istream::traits_type - >(is, flags) - {} - naked_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_iarchive, std::istream::char_type, std::istream::traits_type - >(bsb, flags) - {} -}; - -} // namespace archive -} // namespace boost - -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - -namespace boost { +namespace boost { namespace archive { // do not derive from this class. If you want to extend this functionality @@ -73,9 +36,7 @@ class binary_iarchive : boost::archive::binary_iarchive, std::istream::char_type, std::istream::traits_type - >, - public detail::shared_ptr_helper -{ + >{ public: binary_iarchive(std::istream & is, unsigned int flags = 0) : binary_iarchive_impl< diff --git a/src/thirdparty/boost_lib/boost/archive/binary_iarchive_impl.hpp b/src/thirdparty/boost_lib/boost/archive/binary_iarchive_impl.hpp index 32c476d64..a9afe6168 100644 --- a/src/thirdparty/boost_lib/boost/archive/binary_iarchive_impl.hpp +++ b/src/thirdparty/boost_lib/boost/archive/binary_iarchive_impl.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -29,6 +29,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + template class binary_iarchive_impl : public basic_binary_iprimitive, @@ -37,10 +41,18 @@ class binary_iarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive; - friend class basic_binary_iarchive; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + friend basic_binary_iarchive; + friend load_access; + #else + friend class detail::interface_iarchive; + friend class basic_binary_iarchive; + friend class load_access; + #endif #endif // note: the following should not needed - but one compiler (vc 7.1) // fails to compile one test (test_shared_ptr) without it !!! diff --git a/src/thirdparty/boost_lib/boost/archive/binary_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/binary_oarchive.hpp index 2aac14f90..89a86da41 100644 --- a/src/thirdparty/boost_lib/boost/archive/binary_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/binary_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -50,8 +50,6 @@ class binary_oarchive : {} }; -typedef binary_oarchive naked_binary_oarchive; - } // namespace archive } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/archive/binary_oarchive_impl.hpp b/src/thirdparty/boost_lib/boost/archive/binary_oarchive_impl.hpp index 7ca773b60..a8c97333e 100644 --- a/src/thirdparty/boost_lib/boost/archive/binary_oarchive_impl.hpp +++ b/src/thirdparty/boost_lib/boost/archive/binary_oarchive_impl.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -30,6 +30,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + template class binary_oarchive_impl : public basic_binary_oprimitive, @@ -38,10 +42,18 @@ class binary_oarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive; - friend class basic_binary_oarchive; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + friend basic_binary_oarchive; + friend save_access; + #else + friend class detail::interface_oarchive; + friend class basic_binary_oarchive; + friend class save_access; + #endif #endif // note: the following should not needed - but one compiler (vc 7.1) // fails to compile one test (test_shared_ptr) without it !!! diff --git a/src/thirdparty/boost_lib/boost/archive/binary_wiarchive.hpp b/src/thirdparty/boost_lib/boost/archive/binary_wiarchive.hpp index b5f6a7106..775d8f827 100644 --- a/src/thirdparty/boost_lib/boost/archive/binary_wiarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/binary_wiarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -28,43 +28,6 @@ namespace boost { namespace archive { -// same as binary_wiarchive below - without the shared_ptr_helper -class naked_binary_wiarchive : - public binary_iarchive_impl< - boost::archive::naked_binary_wiarchive, - std::wistream::char_type, - std::wistream::traits_type - > -{ -public: - naked_binary_wiarchive(std::wistream & is, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_wiarchive, - std::wistream::char_type, - std::wistream::traits_type - >(is, flags) - {} - naked_binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) : - binary_iarchive_impl< - naked_binary_wiarchive, - std::wistream::char_type, - std::wistream::traits_type - >(bsb, flags) - {} -}; - -} // namespace archive -} // namespace boost - -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - -namespace boost { -namespace archive { - class binary_wiarchive : public binary_iarchive_impl< binary_wiarchive, std::wistream::char_type, std::wistream::traits_type diff --git a/src/thirdparty/boost_lib/boost/archive/binary_woarchive.hpp b/src/thirdparty/boost_lib/boost/archive/binary_woarchive.hpp index 2075dac8b..a8817d6f8 100644 --- a/src/thirdparty/boost_lib/boost/archive/binary_woarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/binary_woarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -49,8 +49,6 @@ class binary_woarchive : {} }; -typedef binary_woarchive naked_binary_woarchive; - } // namespace archive } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/archive/codecvt_null.hpp b/src/thirdparty/boost_lib/boost/archive/codecvt_null.hpp index 910b26156..caeefee5c 100644 --- a/src/thirdparty/boost_lib/boost/archive/codecvt_null.hpp +++ b/src/thirdparty/boost_lib/boost/archive/codecvt_null.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_CODECVT_NULL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/archive_serializer_map.hpp b/src/thirdparty/boost_lib/boost/archive/detail/archive_serializer_map.hpp index 6d2eec4a8..53fcae404 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/archive_serializer_map.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/archive_serializer_map.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_SERIALIZER_MAP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/auto_link_archive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/auto_link_archive.hpp index 05956f0e8..79b0e490d 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/auto_link_archive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/auto_link_archive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/auto_link_warchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/auto_link_warchive.hpp index 4d4efcd44..683d191c2 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/auto_link_warchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/auto_link_warchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_archive_impl.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_archive_impl.hpp index 589368ddc..b84a50983 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_archive_impl.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_archive_impl.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_config.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_config.hpp index 5e37cae40..4bd2723eb 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_config.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_config.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_iarchive.hpp index f62987ece..fdafbbf84 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -22,10 +22,10 @@ #include #include -#include #include #include #include +#include #include // must be the last header namespace boost { @@ -42,7 +42,8 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer; ////////////////////////////////////////////////////////////////////// // class basic_iarchive - read serialized objects from a input stream class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive : - private boost::noncopyable + private boost::noncopyable, + public boost::archive::detail::helper_collection { friend class basic_iarchive_impl; // hide implementation of this class to minimize header conclusion @@ -99,12 +100,6 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive : } // namespace archive } // namespace boost -// required by smart_cast for compilers not implementing -// partial template specialization -BOOST_TT_BROKEN_COMPILER_SPEC( - boost::archive::detail::basic_iarchive -) - #include // pops abi_suffix.hpp pragmas #endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_iserializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_iserializer.hpp index 2f4f6d811..3bff3e125 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_iserializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_iserializer.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_oarchive.hpp index 402e569a6..f65d11036 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -20,14 +20,12 @@ #include #include -#include - // can't use this - much as I'd like to as borland doesn't support it // #include #include #include - +#include #include // must be the last header namespace boost { @@ -41,10 +39,12 @@ namespace detail { class basic_oarchive_impl; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer; class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer; + ////////////////////////////////////////////////////////////////////// // class basic_oarchive - write serialized objects to an output stream class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive : - private boost::noncopyable + private boost::noncopyable, + public boost::archive::detail::helper_collection { friend class basic_oarchive_impl; // hide implementation of this class to minimize header conclusion @@ -95,12 +95,6 @@ class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive : } // namespace archive } // namespace boost -// required by smart_cast for compilers not implementing -// partial template specialization -BOOST_TT_BROKEN_COMPILER_SPEC( - boost::archive::detail::basic_oarchive -) - #include // pops abi_suffix.hpp pragmas #endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_oserializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_oserializer.hpp index 74af7e657..6ae063f55 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_oserializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_oserializer.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_iserializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_iserializer.hpp index d957b83e6..86badc193 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_iserializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_iserializer.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -52,10 +52,11 @@ class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer #endif ~basic_pointer_iserializer(); public: + virtual void * heap_allocation() const = 0; virtual const basic_iserializer & get_basic_serializer() const = 0; virtual void load_object_ptr( basic_iarchive & ar, - void * & x, + void * x, const unsigned int file_version ) const = 0; }; diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_oserializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_oserializer.hpp index b0d3fb959..bafc46a1d 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_oserializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_pointer_oserializer.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer.hpp index 5dbd88652..c7d3b4bef 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer_map.hpp b/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer_map.hpp index a991ea1dc..202c20e1f 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer_map.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/basic_serializer_map.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZER_MAP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/check.hpp b/src/thirdparty/boost_lib/boost/archive/detail/check.hpp index c9cba519f..10034e7d1 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/check.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/check.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_CHECK_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #pragma inline_depth(511) #pragma inline_recursion(on) @@ -50,7 +50,7 @@ namespace detail { template inline void check_object_level(){ typedef - BOOST_DEDUCED_TYPENAME mpl::greater_equal< + typename mpl::greater_equal< serialization::implementation_level< T >, mpl::int_ >::type typex; @@ -63,12 +63,12 @@ inline void check_object_level(){ template inline void check_object_versioning(){ typedef - BOOST_DEDUCED_TYPENAME mpl::or_< - BOOST_DEDUCED_TYPENAME mpl::greater< + typename mpl::or_< + typename mpl::greater< serialization::implementation_level< T >, mpl::int_ >, - BOOST_DEDUCED_TYPENAME mpl::equal_to< + typename mpl::equal_to< serialization::version< T >, mpl::int_<0> > @@ -83,7 +83,7 @@ inline void check_object_tracking(){ // presume it has already been determined that // T is not a const BOOST_STATIC_ASSERT(! boost::is_const< T >::value); - typedef BOOST_DEDUCED_TYPENAME mpl::equal_to< + typedef typename mpl::equal_to< serialization::tracking_level< T >, mpl::int_ >::type typex; @@ -105,13 +105,13 @@ inline void check_pointer_level(){ // we should only invoke this once we KNOW that T // has been used as a pointer!! typedef - BOOST_DEDUCED_TYPENAME mpl::or_< - BOOST_DEDUCED_TYPENAME mpl::greater< + typename mpl::or_< + typename mpl::greater< serialization::implementation_level< T >, mpl::int_ >, - BOOST_DEDUCED_TYPENAME mpl::not_< - BOOST_DEDUCED_TYPENAME mpl::equal_to< + typename mpl::not_< + typename mpl::equal_to< serialization::tracking_level< T >, mpl::int_ > @@ -139,7 +139,7 @@ inline void check_pointer_level(){ template void inline check_pointer_tracking(){ - typedef BOOST_DEDUCED_TYPENAME mpl::greater< + typedef typename mpl::greater< serialization::tracking_level< T >, mpl::int_ >::type typex; @@ -151,10 +151,10 @@ void inline check_pointer_tracking(){ template inline void check_const_loading(){ typedef - BOOST_DEDUCED_TYPENAME mpl::or_< - BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >, - BOOST_DEDUCED_TYPENAME mpl::not_< - BOOST_DEDUCED_TYPENAME boost::is_const< T > + typename mpl::or_< + typename boost::serialization::is_wrapper< T >, + typename mpl::not_< + typename boost::is_const< T > > >::type typex; // cannot load data into a "const" object unless it's a diff --git a/src/thirdparty/boost_lib/boost/archive/detail/common_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/common_iarchive.hpp index 54c07c39c..45e6d34b3 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/common_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/common_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/common_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/common_oarchive.hpp index 7962063a5..0d7474bcd 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/common_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/common_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/decl.hpp b/src/thirdparty/boost_lib/boost/archive/detail/decl.hpp index 9695001ab..44e22be96 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/decl.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/decl.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_DECL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/helper_collection.hpp b/src/thirdparty/boost_lib/boost/archive/detail/helper_collection.hpp new file mode 100644 index 000000000..ba3c60cd1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/archive/detail/helper_collection.hpp @@ -0,0 +1,111 @@ +#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP +#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// helper_collection.hpp: archive support for run-time helpers + +// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include // NULL +#include +#include +#include +#include +#include + +#include + +#ifdef BOOST_NO_CXX11_SMART_PTR + #include + #include +#endif + +namespace boost { + +namespace archive { +namespace detail { + +class helper_collection +{ + helper_collection(const helper_collection&); // non-copyable + helper_collection& operator = (const helper_collection&); // non-copyable + + // note: we dont' actually "share" the function object pointer + // we only use shared_ptr to make sure that it get's deleted + + #ifndef BOOST_NO_CXX11_SMART_PTR + typedef std::pair< + const std::type_info *, + std::shared_ptr + > helper_value_type; + template + std::shared_ptr make_helper_ptr(){ + return std::make_shared(); + } + #else + typedef std::pair< + const std::type_info *, + boost::shared_ptr + > helper_value_type; + template + boost::shared_ptr make_helper_ptr(){ + return boost::make_shared(); + } + #endif + typedef std::vector collection; + collection m_collection; + + struct predicate { + const std::type_info * m_ti; + bool operator()(helper_value_type const &rhs) const { + return *m_ti == *rhs.first; + } + predicate(const std::type_info * ti) : + m_ti(ti) + {} + }; +protected: + helper_collection(){} + ~helper_collection(){} +public: + template + Helper& get_helper(Helper * = NULL) { + + const std::type_info * eti = & typeid(Helper); + + collection::const_iterator it = + std::find_if( + m_collection.begin(), + m_collection.end(), + predicate(eti) + ); + + void * rval; + if(it == m_collection.end()){ + m_collection.push_back( + std::make_pair(eti, make_helper_ptr()) + ); + rval = m_collection.back().second.get(); + } + else{ + rval = it->second.get(); + } + return *static_cast(rval); + } +}; + +} // namespace detail +} // namespace serialization +} // namespace boost + +#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP diff --git a/src/thirdparty/boost_lib/boost/archive/detail/interface_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/interface_iarchive.hpp index 06487521f..b7bd1659f 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/interface_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/interface_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/interface_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/interface_oarchive.hpp index e8db7a2bc..7ae71768a 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/interface_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/interface_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/iserializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/iserializer.hpp index 53765af31..cf547de0d 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/iserializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/iserializer.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #pragma inline_depth(511) #pragma inline_recursion(on) @@ -23,7 +23,6 @@ // See http://www.boost.org for updates, documentation, and revision history. #include // for placement new -#include // for auto_ptr #include // size_t, NULL #include @@ -59,14 +58,11 @@ namespace std{ #include -#define DONT_USE_HAS_NEW_OPERATOR ( \ +#if ! ( \ defined(__BORLANDC__) \ || BOOST_WORKAROUND(__IBMCPP__, < 1210) \ - || defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) \ || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \ ) - -#if ! DONT_USE_HAS_NEW_OPERATOR #include #endif @@ -127,7 +123,7 @@ class iserializer : public basic_iserializer explicit iserializer() : basic_iserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) @@ -197,85 +193,84 @@ BOOST_DLLEXPORT void iserializer::load_object_data( # pragma warning(disable : 4511 4512) #endif -template -class pointer_iserializer : - public basic_pointer_iserializer -{ -private: - virtual const basic_iserializer & get_basic_serializer() const { - return boost::serialization::singleton< - iserializer - >::get_const_instance(); - } - BOOST_DLLEXPORT virtual void load_object_ptr( - basic_iarchive & ar, - void * & x, - const unsigned int file_version - ) const BOOST_USED; -protected: - // this should alway be a singleton so make the constructor protected - pointer_iserializer(); - ~pointer_iserializer(); -}; - -#ifdef BOOST_MSVC -# pragma warning(pop) -#endif - -// note trick to be sure that operator new is using class specific -// version if such exists. Due to Peter Dimov. -// note: the following fails if T has no default constructor. -// otherwise it would have been ideal -//struct heap_allocator : public T -//{ -// T * invoke(){ -// return ::new(sizeof(T)); -// } -//} +// the purpose of this code is to allocate memory for an object +// without requiring the constructor to be called. Presumably +// the allocated object will be subsequently initialized with +// "placement new". +// note: we have the boost type trait has_new_operator but we +// have no corresponding has_delete_operator. So we presume +// that the former being true would imply that the a delete +// operator is also defined for the class T. template -struct heap_allocator -{ +struct heap_allocation { // boost::has_new_operator< T > doesn't work on these compilers #if DONT_USE_HAS_NEW_OPERATOR // This doesn't handle operator new overload for class T - static T * invoke(){ + static T * invoke_new(){ return static_cast(operator new(sizeof(T))); } + static viod invoke_delete(){ + (operator delete(sizeof(T))); + } #else + // note: we presume that a true value for has_new_operator + // implies the existence of a class specific delete operator as well + // as a class specific new operator. struct has_new_operator { - static T* invoke() { + static T * invoke_new() { return static_cast((T::operator new)(sizeof(T))); } + static void invoke_delete(T * t) { + // if compilation fails here, the likely cause that the class + // T has a class specific new operator but no class specific + // delete operator which matches the following signature. Fix + // your program to have this. Note that adding operator delete + // with only one parameter doesn't seem correct to me since + // the standard(3.7.4.2) says " + // "If a class T has a member deallocation function named + // 'operator delete' with exactly one parameter, then that function + // is a usual (non-placement) deallocation function" which I take + // to mean that it will call the destructor of type T which we don't + // want to do here. + // Note: reliance upon automatic conversion from T * to void * here + (T::operator delete)(t, sizeof(T)); + } }; struct doesnt_have_new_operator { - static T* invoke() { + static T* invoke_new() { return static_cast(operator new(sizeof(T))); } + static void invoke_delete(T * t) { + // Note: I'm reliance upon automatic conversion from T * to void * here + (operator delete)(t); + } }; - static T * invoke() { - typedef BOOST_DEDUCED_TYPENAME + static T * invoke_new() { + typedef typename mpl::eval_if< boost::has_new_operator< T >, mpl::identity, mpl::identity >::type typex; - return typex::invoke(); + return typex::invoke_new(); + } + static void invoke_delete(T *t) { + typedef typename + mpl::eval_if< + boost::has_new_operator< T >, + mpl::identity, + mpl::identity + >::type typex; + typex::invoke_delete(t); } #endif -}; - -// due to Martin Ecker -template -class auto_ptr_with_deleter -{ -public: - explicit auto_ptr_with_deleter(T* p) : - m_p(p) - {} - ~auto_ptr_with_deleter(){ - if (m_p) - boost::serialization::access::destroy(m_p); + explicit heap_allocation(){ + m_p = invoke_new(); + } + ~heap_allocation(){ + if (0 != m_p) + invoke_delete(m_p); } T* get() const { return m_p; @@ -283,60 +278,88 @@ class auto_ptr_with_deleter T* release() { T* p = m_p; - m_p = NULL; + m_p = 0; return p; } private: T* m_p; }; +template +class pointer_iserializer : + public basic_pointer_iserializer +{ +private: + virtual void * heap_allocation() const { + detail::heap_allocation h; + T * t = h.get(); + h.release(); + return t; + } + virtual const basic_iserializer & get_basic_serializer() const { + return boost::serialization::singleton< + iserializer + >::get_const_instance(); + } + BOOST_DLLEXPORT virtual void load_object_ptr( + basic_iarchive & ar, + void * x, + const unsigned int file_version + ) const BOOST_USED; +protected: + // this should alway be a singleton so make the constructor protected + pointer_iserializer(); + ~pointer_iserializer(); +}; + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + // note: BOOST_DLLEXPORT is so that code for polymorphic class // serialized only through base class won't get optimized out template BOOST_DLLEXPORT void pointer_iserializer::load_object_ptr( basic_iarchive & ar, - void * & x, + void * t, const unsigned int file_version ) const { Archive & ar_impl = boost::serialization::smart_cast_reference(ar); - auto_ptr_with_deleter< T > ap(heap_allocator< T >::invoke()); - if(NULL == ap.get()) - boost::serialization::throw_exception(std::bad_alloc()) ; - - T * t = ap.get(); - x = t; + // note that the above will throw std::bad_alloc if the allocation + // fails so we don't have to address this contingency here. // catch exception during load_construct_data so that we don't // automatically delete the t which is most likely not fully // constructed BOOST_TRY { - // this addresses an obscure situtation that occurs when + // this addresses an obscure situation that occurs when // load_constructor de-serializes something through a pointer. ar.next_object_pointer(t); boost::serialization::load_construct_data_adl( ar_impl, - t, + static_cast(t), file_version ); } BOOST_CATCH(...){ - ap.release(); + // if we get here the load_construct failed. The heap_allocation + // will be automatically deleted so we don't have to do anything + // special here. BOOST_RETHROW; } BOOST_CATCH_END - ar_impl >> boost::serialization::make_nvp(NULL, * t); - ap.release(); + ar_impl >> boost::serialization::make_nvp(NULL, * static_cast(t)); } template pointer_iserializer::pointer_iserializer() : basic_pointer_iserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) @@ -405,7 +428,7 @@ struct load_non_pointer_type { template static void invoke(Archive & ar, T &t){ - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< // if its primitive mpl::equal_to< boost::serialization::implementation_level< T >, @@ -413,7 +436,7 @@ struct load_non_pointer_type { >, mpl::identity, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // class info / version mpl::greater_equal< boost::serialization::implementation_level< T >, @@ -422,7 +445,7 @@ struct load_non_pointer_type { // do standard load mpl::identity, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // no tracking mpl::equal_to< boost::serialization::tracking_level< T >, @@ -466,7 +489,7 @@ struct load_pointer_type { // class pointer. Inhibiting code generation for this // permits abstract base classes to be used - note: exception // virtual serialize functions used for plug-ins - typedef BOOST_DEDUCED_TYPENAME + typedef typename mpl::eval_if< boost::serialization::is_abstract, boost::mpl::identity, @@ -482,18 +505,21 @@ struct load_pointer_type { const T & ) { // tweak the pointer back to the base class - return static_cast( - const_cast( - boost::serialization::void_upcast( - eti, - boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME - boost::serialization::type_info_implementation< T >::type - >::get_const_instance(), - t - ) + void * upcast = const_cast( + boost::serialization::void_upcast( + eti, + boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< T >::type + >::get_const_instance(), + t ) ); + if(NULL == upcast) + boost::serialization::throw_exception( + archive_exception(archive_exception::unregistered_class) + ); + return static_cast(upcast); } template @@ -544,7 +570,7 @@ template struct load_array_type { template static void invoke(Archive &ar, T &t){ - typedef BOOST_DEDUCED_TYPENAME remove_extent< T >::type value_type; + typedef typename remove_extent< T >::type value_type; // convert integers to correct enum to load // determine number of elements in the array. Consider the @@ -576,13 +602,13 @@ inline void load(Archive & ar, T &t){ // handled below. detail::check_const_loading< T >(); typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity > ,//else - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity > ,//else - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity > ,//else mpl::identity > diff --git a/src/thirdparty/boost_lib/boost/archive/detail/oserializer.hpp b/src/thirdparty/boost_lib/boost/archive/detail/oserializer.hpp index 7d2694d77..7a7e23937 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/oserializer.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/oserializer.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_OSERIALIZER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #pragma inline_depth(511) #pragma inline_recursion(on) @@ -106,7 +106,7 @@ class oserializer : public basic_oserializer explicit BOOST_DLLEXPORT oserializer() : basic_oserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) @@ -205,7 +205,7 @@ template pointer_oserializer::pointer_oserializer() : basic_pointer_oserializer( boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance() ) @@ -275,7 +275,7 @@ struct save_non_pointer_type { template static void invoke(Archive & ar, const T & t){ typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // if its primitive mpl::equal_to< boost::serialization::implementation_level< T >, @@ -283,7 +283,7 @@ struct save_non_pointer_type { >, mpl::identity, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // class info / version mpl::greater_equal< boost::serialization::implementation_level< T >, @@ -292,7 +292,7 @@ struct save_non_pointer_type { // do standard save mpl::identity, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // no tracking mpl::equal_to< boost::serialization::tracking_level< T >, @@ -342,7 +342,7 @@ struct save_pointer_type { // permits abstract base classes to be used - note: exception // virtual serialize functions used for plug-ins typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< boost::serialization::is_abstract< T >, mpl::identity, mpl::identity @@ -373,10 +373,10 @@ struct save_pointer_type { Archive &ar, T & t ){ - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type const & i = boost::serialization::singleton< - BOOST_DEDUCED_TYPENAME + typename boost::serialization::type_info_implementation< T >::type >::get_const_instance(); @@ -452,7 +452,7 @@ struct save_pointer_type { ){ check_pointer_level< T >(); check_pointer_tracking< T >(); - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< is_polymorphic< T >, mpl::identity, mpl::identity @@ -490,7 +490,7 @@ struct save_array_type { template static void invoke(Archive &ar, const T &t){ - typedef BOOST_DEDUCED_TYPENAME boost::remove_extent< T >::type value_type; + typedef typename boost::remove_extent< T >::type value_type; save_access::end_preamble(ar); // consider alignment @@ -509,13 +509,13 @@ struct save_array_type template inline void save(Archive & ar, /*const*/ T &t){ typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity >, //else mpl::identity > diff --git a/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_iarchive_route.hpp b/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_iarchive_route.hpp index d93bb79cb..a8eb7aa94 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_iarchive_route.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_iarchive_route.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_oarchive_route.hpp b/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_oarchive_route.hpp index f1b20f8bf..9211df2aa 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_oarchive_route.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/polymorphic_oarchive_route.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/detail/register_archive.hpp b/src/thirdparty/boost_lib/boost/archive/detail/register_archive.hpp index e31ae46c0..81a19b9cf 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/register_archive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/register_archive.hpp @@ -81,7 +81,7 @@ void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {} namespace boost { namespace archive { namespace detail { \ \ template \ -BOOST_DEDUCED_TYPENAME _ptr_serialization_support::type \ +typename _ptr_serialization_support::type \ instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \ \ }}} diff --git a/src/thirdparty/boost_lib/boost/archive/detail/utf8_codecvt_facet.hpp b/src/thirdparty/boost_lib/boost/archive/detail/utf8_codecvt_facet.hpp index bd859ffeb..b2430d5a4 100644 --- a/src/thirdparty/boost_lib/boost/archive/detail/utf8_codecvt_facet.hpp +++ b/src/thirdparty/boost_lib/boost/archive/detail/utf8_codecvt_facet.hpp @@ -7,15 +7,17 @@ #ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP #define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP -#define BOOST_UTF8_BEGIN_NAMESPACE \ - namespace boost { namespace archive { namespace detail { -#define BOOST_UTF8_DECL -#define BOOST_UTF8_END_NAMESPACE }}} +#ifdef BOOST_NO_CXX11_HDR_CODECVT + #define BOOST_UTF8_BEGIN_NAMESPACE \ + namespace boost { namespace archive { namespace detail { + #define BOOST_UTF8_DECL + #define BOOST_UTF8_END_NAMESPACE }}} -#include - -#undef BOOST_UTF8_END_NAMESPACE -#undef BOOST_UTF8_DECL -#undef BOOST_UTF8_BEGIN_NAMESPACE + #include + #undef BOOST_UTF8_END_NAMESPACE + #undef BOOST_UTF8_DECL + #undef BOOST_UTF8_BEGIN_NAMESPACE +#endif // BOOST_NO_CXX11_HDR_CODECVT #endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP + diff --git a/src/thirdparty/boost_lib/boost/archive/dinkumware.hpp b/src/thirdparty/boost_lib/boost/archive/dinkumware.hpp index bfa828d53..90ba6271c 100644 --- a/src/thirdparty/boost_lib/boost/archive/dinkumware.hpp +++ b/src/thirdparty/boost_lib/boost/archive/dinkumware.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_DINKUMWARE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iarchive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iarchive.ipp index 8ea39f700..b8e7f454c 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iarchive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iarchive.ipp @@ -12,7 +12,7 @@ #include #include -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; @@ -51,6 +51,8 @@ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iarchive::init(){ // read signature in an archive version independent manner std::string file_signature; + + #if 0 // commented out since it interfers with derivation try { std::size_t l; this->This()->load(l); @@ -69,6 +71,11 @@ basic_binary_iarchive::init(){ // will cause invalid_signature archive exception to be thrown below file_signature = ""; } + #else + // https://svn.boost.org/trac/boost/ticket/7301 + * this->This() >> file_signature; + #endif + if(file_signature != BOOST_ARCHIVE_SIGNATURE()) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_signature) @@ -113,10 +120,7 @@ basic_binary_iarchive::init(){ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) this->set_library_version(input_library_version); #else - #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) - detail:: - #endif - basic_iarchive::set_library_version(input_library_version); + detail::basic_iarchive::set_library_version(input_library_version); #endif if(BOOST_ARCHIVE_VERSION() < input_library_version) diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iprimitive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iprimitive.ipp index e0f5c2ea1..9e2340eb2 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iprimitive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_iprimitive.ipp @@ -28,6 +28,7 @@ namespace std{ #include #include #include +#include namespace boost { namespace archive { diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oarchive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oarchive.ipp index dec2cd77a..467fd6fe9 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oarchive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oarchive.ipp @@ -12,7 +12,7 @@ #include #include -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oprimitive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oprimitive.ipp index 02b5ffab9..509decb4e 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oprimitive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_binary_oprimitive.ipp @@ -31,6 +31,7 @@ namespace std{ using ::wcslen; } #include #include +#include namespace boost { namespace archive { diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iarchive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iarchive.ipp index 0a246b76c..8d364f9b5 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iarchive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iarchive.ipp @@ -11,7 +11,7 @@ #include #include -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; @@ -62,10 +62,7 @@ basic_text_iarchive::init(void){ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) this->set_library_version(input_library_version); #else - #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) - detail:: - #endif - basic_iarchive::set_library_version(input_library_version); + detail::basic_iarchive::set_library_version(input_library_version); #endif // extra little .t is to get around borland quirk diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iprimitive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iprimitive.ipp index 16378b843..d0da2840d 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iprimitive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_iprimitive.ipp @@ -30,10 +30,10 @@ namespace std{ #include #include -namespace boost { +namespace boost { namespace archive { -namespace { +namespace detail { template bool is_whitespace(CharType c); @@ -48,7 +48,7 @@ namespace { return 0 != std::iswspace(t); } #endif -} +} // detail // translate base64 text into binary and copy into buffer // until buffer is full. @@ -58,7 +58,7 @@ basic_text_iprimitive::load_binary( void *address, std::size_t count ){ - typedef BOOST_DEDUCED_TYPENAME IStream::char_type CharType; + typedef typename IStream::char_type CharType; if(0 == count) return; @@ -73,7 +73,7 @@ basic_text_iprimitive::load_binary( archive_exception(archive_exception::input_stream_error) ); // convert from base64 to binary - typedef BOOST_DEDUCED_TYPENAME + typedef typename iterators::transform_width< iterators::binary_from_base64< iterators::remove_whitespace< @@ -102,11 +102,11 @@ basic_text_iprimitive::load_binary( // skip over any excess input for(;;){ - BOOST_DEDUCED_TYPENAME IStream::int_type r; + typename IStream::int_type r; r = is.get(); if(is.eof()) break; - if(is_whitespace(static_cast(r))) + if(detail::is_whitespace(static_cast(r))) break; } } @@ -128,7 +128,7 @@ basic_text_iprimitive::basic_text_iprimitive( archive_locale.reset( add_facet( std::locale::classic(), - new codecvt_null + new codecvt_null ) ); is.imbue(* archive_locale); diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oarchive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oarchive.ipp index 34e6995ce..4170c9718 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oarchive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oarchive.ipp @@ -11,7 +11,7 @@ #include #include -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oprimitive.ipp b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oprimitive.ipp index 7e4315c0d..33ab4a8b6 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oprimitive.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_text_oprimitive.ipp @@ -9,6 +9,7 @@ // See http://www.boost.org for updates, documentation, and revision history. #include // NULL +#include // std::copy #include #include @@ -30,7 +31,7 @@ basic_text_oprimitive::save_binary( const void *address, std::size_t count ){ - typedef BOOST_DEDUCED_TYPENAME OStream::char_type CharType; + typedef typename OStream::char_type CharType; if(0 == count) return; @@ -90,7 +91,7 @@ basic_text_oprimitive::basic_text_oprimitive( archive_locale.reset( add_facet( std::locale::classic(), - new codecvt_null + new codecvt_null ) ); os.imbue(* archive_locale); diff --git a/src/thirdparty/boost_lib/boost/archive/impl/basic_xml_grammar.hpp b/src/thirdparty/boost_lib/boost/archive/impl/basic_xml_grammar.hpp index 807ed0722..66ca1f0b2 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/basic_xml_grammar.hpp +++ b/src/thirdparty/boost_lib/boost/archive/impl/basic_xml_grammar.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -50,11 +50,6 @@ #include #include -// supress noise -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif - #include #include diff --git a/src/thirdparty/boost_lib/boost/archive/impl/xml_iarchive_impl.ipp b/src/thirdparty/boost_lib/boost/archive/impl/xml_iarchive_impl.ipp index c7cbc7fcd..dc62eed33 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/xml_iarchive_impl.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/xml_iarchive_impl.ipp @@ -98,9 +98,9 @@ xml_iarchive_impl::load(wchar_t * ws){ const char * end = start + s.size(); while(start < end){ wchar_t wc; - int result = std::mbtowc(&wc, start, end - start); - if(0 < result){ - start += result; + int length = std::mbtowc(&wc, start, end - start); + if(0 < length){ + start += length; *ws++ = wc; continue; } diff --git a/src/thirdparty/boost_lib/boost/archive/impl/xml_oarchive_impl.ipp b/src/thirdparty/boost_lib/boost/archive/impl/xml_oarchive_impl.ipp index 8ab954f4a..ab1a2177b 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/xml_oarchive_impl.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/xml_oarchive_impl.ipp @@ -8,7 +8,7 @@ #include #include -#include +#include // std::copy #include #include // strlen diff --git a/src/thirdparty/boost_lib/boost/archive/impl/xml_wiarchive_impl.ipp b/src/thirdparty/boost_lib/boost/archive/impl/xml_wiarchive_impl.ipp index 9dde66c87..a4665ad4c 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/xml_wiarchive_impl.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/xml_wiarchive_impl.ipp @@ -1,5 +1,5 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// xml_wiprimitive.cpp: +// xml_wiarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Distributed under the Boost Software License, Version 1.0. (See @@ -8,8 +8,6 @@ // See http://www.boost.org for updates, documentation, and revision history. -#include // for BOOST_DEDUCED_TYPENAME - #include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ @@ -21,7 +19,7 @@ namespace std{ #ifndef BOOST_NO_STD_WSTREAMBUF #include -#include +#include // std::copy #include // Dinkumware and RogueWave #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) @@ -34,9 +32,16 @@ namespace std{ #include #include -#include -#include +#ifndef BOOST_NO_CXX11_HDR_CODECVT + #include + namespace boost { namespace archive { namespace detail { + typedef std::codecvt_utf8 utf8_codecvt_facet; + } } } +#else + #include +#endif +#include #include #include @@ -167,7 +172,7 @@ xml_wiarchive_impl::xml_wiarchive_impl( if(0 == (flags & no_codecvt)){ archive_locale.reset( add_facet( - std::locale::classic(), + is_.getloc(), new boost::archive::detail::utf8_codecvt_facet ) ); diff --git a/src/thirdparty/boost_lib/boost/archive/impl/xml_woarchive_impl.ipp b/src/thirdparty/boost_lib/boost/archive/impl/xml_woarchive_impl.ipp index 3bf42bdac..6092a9152 100644 --- a/src/thirdparty/boost_lib/boost/archive/impl/xml_woarchive_impl.ipp +++ b/src/thirdparty/boost_lib/boost/archive/impl/xml_woarchive_impl.ipp @@ -11,15 +11,14 @@ #include #include -#include +#include // std::copy #include -#include // msvc 6.0 needs this to suppress warnings - // for BOOST_DEDUCED_TYPENAME #include // strlen #include // mbtowc #include // wcslen +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::strlen; @@ -39,7 +38,14 @@ namespace std{ #include #include -#include +#ifndef BOOST_NO_CXX11_HDR_CODECVT + #include + namespace boost { namespace archive { namespace detail { + typedef std::codecvt_utf8 utf8_codecvt_facet; + } } } +#else + #include +#endif namespace boost { namespace archive { @@ -128,26 +134,27 @@ xml_woarchive_impl::xml_woarchive_impl( // a) before output is invoked or // b) after flush has been called. This prevents one-to-many // transforms (such as one to many transforms from getting - // mixed up. Unfortunately, STLPort doesn't respect b) above - // so the restoration of the original archive locale done by - // the locale_saver doesn't get processed, - // before the current one is destroyed. - // so the codecvt doesn't get replaced with the orginal - // so closing the stream invokes codecvt::do_unshift - // so it crashes because the corresponding locale that contained - // the codecvt isn't around any more. - // we can hack around this by using a static codecvt that never - // gets destroyed. + // mixed up. if(0 == (flags & no_codecvt)){ boost::archive::detail::utf8_codecvt_facet *pfacet; #if defined(__SGI_STL_PORT) - static boost::archive::detail::utf8_codecvt_facet + // Unfortunately, STLPort doesn't respect b) above + // so the restoration of the original archive locale done by + // the locale_saver doesn't get processed, + // before the current one is destroyed. + // so the codecvt doesn't get replaced with the orginal + // so closing the stream invokes codecvt::do_unshift + // so it crashes because the corresponding locale that contained + // the codecvt isn't around any more. + // we can hack around this by using a static codecvt that never + // gets destroyed. + static boost::archive::detail::utf8_codecvt_facet facet(static_cast(1)); pfacet = & facet; #else pfacet = new boost::archive::detail::utf8_codecvt_facet; #endif - archive_locale.reset(add_facet(std::locale::classic(), pfacet)); + archive_locale.reset(add_facet(os_.getloc(), pfacet)); os.imbue(* archive_locale); } if(0 == (flags & no_header)) diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/base64_exception.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/base64_exception.hpp index 81ad28ed8..8f9208b60 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/base64_exception.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/base64_exception.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/base64_from_binary.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/base64_from_binary.hpp index ecb916a06..836d93de3 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/base64_from_binary.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/base64_from_binary.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -19,7 +19,6 @@ #include #include // size_t -#include // for BOOST_DEDUCED_TYPENAME #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; @@ -57,7 +56,7 @@ struct from_6_bit { } // namespace detail // note: what we would like to do is -// template +// template // typedef transform_iterator< // from_6_bit, // transform_width @@ -69,10 +68,10 @@ struct from_6_bit { // a templated constructor. This makes it incompatible with the dataflow // ideal. This is also addressed here. -//template +//template template< class Base, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value::type + class CharType = typename boost::iterator_value::type > class base64_from_binary : public transform_iterator< @@ -82,7 +81,7 @@ class base64_from_binary : { friend class boost::iterator_core_access; typedef transform_iterator< - BOOST_DEDUCED_TYPENAME detail::from_6_bit, + typename detail::from_6_bit, Base > super_t; diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/binary_from_base64.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/binary_from_base64.hpp index 2fe8292f1..9d2c87ebe 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/binary_from_base64.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/binary_from_base64.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,7 +18,6 @@ #include -#include // for BOOST_DEDUCED_TYPENAME #include #include #include @@ -67,7 +66,7 @@ struct to_6_bit { } // namespace detail // note: what we would like to do is -// template +// template // typedef transform_iterator< // from_6_bit, // transform_width @@ -81,7 +80,7 @@ struct to_6_bit { template< class Base, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value::type + class CharType = typename boost::iterator_value::type > class binary_from_base64 : public transform_iterator< diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/dataflow.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/dataflow.hpp index 1623b67b7..6f8001d3c 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/dataflow.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/dataflow.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,8 +18,6 @@ #include -#include // for BOOST_DEDUCED_TYPENAME - #include #include #include diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/dataflow_exception.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/dataflow_exception.hpp index 1d655a1e4..e3e18605b 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/dataflow_exception.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/dataflow_exception.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/escape.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/escape.hpp index bb527d439..a1fee9142 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/escape.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/escape.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -19,7 +19,6 @@ #include #include // NULL -#include // for BOOST_DEDUCED_TYPENAME #include #include @@ -35,16 +34,16 @@ class escape : public boost::iterator_adaptor< Derived, Base, - BOOST_DEDUCED_TYPENAME boost::iterator_value::type, + typename boost::iterator_value::type, single_pass_traversal_tag, - BOOST_DEDUCED_TYPENAME boost::iterator_value::type + typename boost::iterator_value::type > { - typedef BOOST_DEDUCED_TYPENAME boost::iterator_value::type base_value_type; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference::type reference_type; + typedef typename boost::iterator_value::type base_value_type; + typedef typename boost::iterator_reference::type reference_type; friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< Derived, Base, base_value_type, diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/head_iterator.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/head_iterator.hpp index 2fdd475e1..6ad7d6b32 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/head_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/head_iterator.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/insert_linebreaks.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/insert_linebreaks.hpp index 5f826cacc..7fbc79f13 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/insert_linebreaks.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/insert_linebreaks.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,7 +18,7 @@ #include -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif @@ -37,7 +37,7 @@ namespace iterators { template< class Base, int N, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value::type + class CharType = typename boost::iterator_value::type > class insert_linebreaks : public iterator_adaptor< diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/istream_iterator.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/istream_iterator.hpp index 478f112ff..41aa0be37 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/istream_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/istream_iterator.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -41,13 +41,13 @@ class istream_iterator : { friend class boost::iterator_core_access; typedef istream_iterator this_t ; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_facade< + typedef typename boost::iterator_facade< istream_iterator, Elem, std::input_iterator_tag, Elem > super_t; - typedef BOOST_DEDUCED_TYPENAME std::basic_istream istream_type; + typedef typename std::basic_istream istream_type; bool equal(const this_t & rhs) const { // note: only works for comparison against end of stream diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/mb_from_wchar.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/mb_from_wchar.hpp index d8f8a129f..04e7c7e9f 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/mb_from_wchar.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/mb_from_wchar.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -20,7 +20,7 @@ #include // size_t #include // for wctomb() -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; @@ -50,7 +50,7 @@ class mb_from_wchar { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< mb_from_wchar, Base, wchar_t, diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/ostream_iterator.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/ostream_iterator.hpp index 7c3203f12..49a9b9903 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/ostream_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/ostream_iterator.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/remove_whitespace.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/remove_whitespace.hpp index a01049faf..438398705 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/remove_whitespace.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/remove_whitespace.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,17 +18,12 @@ #include -#include // for BOOST_DEDUCED_TYPENAME - #include #include #include #include -//#include -//#if ! BOOST_WORKAROUND(BOOST_MSVC, <=1300) - // here is the default standard implementation of the functor used // by the filter iterator to remove spaces. Unfortunately usage // of this implementation in combination with spirit trips a bug @@ -53,8 +48,6 @@ namespace std{ using ::isspace; } #undef iswspace #endif -//#endif // BOOST_WORKAROUND - namespace { // anonymous template @@ -100,14 +93,14 @@ class filter_iterator > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< filter_iterator, Base, use_default, single_pass_traversal_tag > super_t; typedef filter_iterator this_t; - typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type; + typedef typename super_t::reference reference_type; reference_type dereference_impl(){ if(! m_full){ @@ -142,8 +135,8 @@ template class remove_whitespace : public filter_iterator< remove_whitespace_predicate< - BOOST_DEDUCED_TYPENAME boost::iterator_value::type - //BOOST_DEDUCED_TYPENAME Base::value_type + typename boost::iterator_value::type + //typename Base::value_type >, Base > @@ -151,8 +144,8 @@ class remove_whitespace : friend class boost::iterator_core_access; typedef filter_iterator< remove_whitespace_predicate< - BOOST_DEDUCED_TYPENAME boost::iterator_value::type - //BOOST_DEDUCED_TYPENAME Base::value_type + typename boost::iterator_value::type + //typename Base::value_type >, Base > super_t; diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/transform_width.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/transform_width.hpp index 5a5c7b757..4e11953bc 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/transform_width.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/transform_width.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -24,12 +24,13 @@ // character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters // or 3 8 bit characters -#include // for BOOST_DEDUCED_TYPENAME & PTFO #include #include #include +#include // std::min + namespace boost { namespace archive { namespace iterators { @@ -41,7 +42,7 @@ template< class Base, int BitsOut, int BitsIn, - class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value::type // output character + class CharType = typename boost::iterator_value::type // output character > class transform_width : public boost::iterator_adaptor< @@ -53,7 +54,7 @@ class transform_width : > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< transform_width, Base, CharType, @@ -62,7 +63,7 @@ class transform_width : > super_t; typedef transform_width this_t; - typedef BOOST_DEDUCED_TYPENAME iterator_value::type base_value_type; + typedef typename iterator_value::type base_value_type; void fill(); @@ -112,6 +113,10 @@ class transform_width : transform_width(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))), m_buffer_out_full(false), + // To disable GCC warning, but not truly necessary + //(m_buffer_in will be initialized later before being + //used because m_remaining_bits == 0) + m_buffer_in(0), m_remaining_bits(0), m_end_of_sequence(false) {} @@ -119,8 +124,8 @@ class transform_width : transform_width(const transform_width & rhs) : super_t(rhs.base_reference()), m_buffer_out_full(rhs.m_buffer_out_full), - m_remaining_bits(rhs.m_remaining_bits), m_buffer_in(rhs.m_buffer_in), + m_remaining_bits(rhs.m_remaining_bits), m_end_of_sequence(false) {} }; diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/unescape.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/unescape.hpp index 9cbd3161c..abf624060 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/unescape.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/unescape.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,9 +18,7 @@ #include -#include // for BOOST_DEDUCED_TYPENAME #include -//#include #include namespace boost { @@ -35,24 +33,24 @@ class unescape : public boost::iterator_adaptor< unescape, Base, - BOOST_DEDUCED_TYPENAME pointee::type, + typename pointee::type, single_pass_traversal_tag, - BOOST_DEDUCED_TYPENAME pointee::type + typename pointee::type > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< unescape, Base, - BOOST_DEDUCED_TYPENAME pointee::type, + typename pointee::type, single_pass_traversal_tag, - BOOST_DEDUCED_TYPENAME pointee::type + typename pointee::type > super_t; typedef unescape this_t; public: - typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type; - typedef BOOST_DEDUCED_TYPENAME this_t::reference reference; + typedef typename this_t::value_type value_type; + typedef typename this_t::reference reference; private: value_type dereference_impl() { if(! m_full){ diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/wchar_from_mb.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/wchar_from_mb.hpp index 4da81215f..ab81f17b6 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/wchar_from_mb.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/wchar_from_mb.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -21,7 +21,7 @@ #include // size_t #include // mblen -#include // for BOOST_DEDUCED_TYPENAME +#include #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::mblen; @@ -53,7 +53,7 @@ class wchar_from_mb > { friend class boost::iterator_core_access; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor< + typedef typename boost::iterator_adaptor< wchar_from_mb, Base, wchar_t, diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/xml_escape.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/xml_escape.hpp index eadb96e8b..a5d2c5120 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/xml_escape.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/xml_escape.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -17,10 +17,7 @@ // See http://www.boost.org for updates, documentation, and revision history. #include - -#include // for BOOST_DEDUCED_TYPENAME #include - #include namespace boost { diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape.hpp index 3295adb39..69438ed04 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,8 +18,6 @@ #include -#include // for BOOST_DEDUCED_TYPENAME - #include #include @@ -39,7 +37,7 @@ class xml_unescape friend class boost::iterator_core_access; typedef xml_unescape this_t; typedef unescape super_t; - typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference reference_type; + typedef typename boost::iterator_reference reference_type; reference_type dereference() const { return unescape, Base>::dereference(); @@ -49,7 +47,7 @@ class xml_unescape #if defined(BOOST_MSVC) typedef int value_type; #else - typedef BOOST_DEDUCED_TYPENAME this_t::value_type value_type; + typedef typename this_t::value_type value_type; #endif void drain_residue(const char *literal); @@ -83,7 +81,7 @@ void xml_unescape::drain_residue(const char * literal){ // iterator refenence which would make subsequent iterator comparisons // incorrect and thereby break the composiblity of iterators. template -BOOST_DEDUCED_TYPENAME xml_unescape::value_type +typename xml_unescape::value_type //int xml_unescape::drain(){ value_type retval = * this->base_reference(); diff --git a/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape_exception.hpp b/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape_exception.hpp index 259d2ba26..71a64378c 100644 --- a/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape_exception.hpp +++ b/src/thirdparty/boost_lib/boost/archive/iterators/xml_unescape_exception.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_iarchive.hpp index ce7e3b060..4a898a8ad 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -29,11 +29,11 @@ namespace boost { namespace archive { class polymorphic_binary_iarchive : - public detail::polymorphic_iarchive_route + public detail::polymorphic_iarchive_route { public: polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) : - detail::polymorphic_iarchive_route(is, flags) + detail::polymorphic_iarchive_route(is, flags) {} ~polymorphic_binary_iarchive(){} }; diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_oarchive.hpp index a66ebddca..931b243fe 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_binary_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -25,7 +25,7 @@ namespace archive { typedef detail::polymorphic_oarchive_route< binary_oarchive_impl< - naked_binary_oarchive, + binary_oarchive, std::ostream::char_type, std::ostream::traits_type > diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_iarchive.hpp index 2f76cf267..50488a331 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -39,8 +39,6 @@ namespace std{ #include // must be the last header namespace boost { -template -class shared_ptr; namespace serialization { class extended_type_info; } // namespace serialization @@ -155,18 +153,11 @@ class polymorphic_iarchive_impl : #include // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - -namespace boost { +namespace boost { namespace archive { class polymorphic_iarchive : - public polymorphic_iarchive_impl, - public detail::shared_ptr_helper + public polymorphic_iarchive_impl { public: virtual ~polymorphic_iarchive(){}; diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_oarchive.hpp index 420029b5b..1eb9e0b41 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -38,8 +38,6 @@ namespace std{ #include // must be the last header namespace boost { -template -class shared_ptr; namespace serialization { class extended_type_info; } // namespace serialization diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_iarchive.hpp index 931a9287c..7bef29278 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -29,11 +29,11 @@ namespace boost { namespace archive { class polymorphic_text_iarchive : - public detail::polymorphic_iarchive_route + public detail::polymorphic_iarchive_route { public: polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) : - detail::polymorphic_iarchive_route(is, flags) + detail::polymorphic_iarchive_route(is, flags) {} ~polymorphic_text_iarchive(){} }; diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_oarchive.hpp index 82b48924f..457aad9fd 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -24,7 +24,7 @@ namespace boost { namespace archive { typedef detail::polymorphic_oarchive_route< - text_oarchive_impl + text_oarchive_impl > polymorphic_text_oarchive; } // namespace archive diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_wiarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_wiarchive.hpp index 4df3d4735..8466f05d6 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_wiarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_wiarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -33,11 +33,11 @@ namespace boost { namespace archive { class polymorphic_text_wiarchive : - public detail::polymorphic_iarchive_route + public detail::polymorphic_iarchive_route { public: polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) : - detail::polymorphic_iarchive_route(is, flags) + detail::polymorphic_iarchive_route(is, flags) {} ~polymorphic_text_wiarchive(){} }; diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_woarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_woarchive.hpp index bc4494741..295625d1b 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_text_woarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_text_woarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -28,7 +28,7 @@ namespace boost { namespace archive { typedef detail::polymorphic_oarchive_route< - text_woarchive_impl + text_woarchive_impl > polymorphic_text_woarchive; } // namespace archive diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_iarchive.hpp index feb0b99bc..4dc3f894b 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -29,11 +29,11 @@ namespace boost { namespace archive { class polymorphic_xml_iarchive : - public detail::polymorphic_iarchive_route + public detail::polymorphic_iarchive_route { public: polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) : - detail::polymorphic_iarchive_route(is, flags) + detail::polymorphic_iarchive_route(is, flags) {} ~polymorphic_xml_iarchive(){} }; diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_oarchive.hpp index 857669428..514f9e530 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -24,7 +24,7 @@ namespace boost { namespace archive { typedef detail::polymorphic_oarchive_route< - xml_oarchive_impl + xml_oarchive_impl > polymorphic_xml_oarchive; } // namespace archive diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_wiarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_wiarchive.hpp index b3f7db258..d4ab73126 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_wiarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_wiarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -28,11 +28,11 @@ namespace boost { namespace archive { class polymorphic_xml_wiarchive : - public detail::polymorphic_iarchive_route + public detail::polymorphic_iarchive_route { public: polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) : - detail::polymorphic_iarchive_route(is, flags) + detail::polymorphic_iarchive_route(is, flags) {} ~polymorphic_xml_wiarchive(){} }; diff --git a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_woarchive.hpp b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_woarchive.hpp index 8884b43c7..dd8963fbb 100644 --- a/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_woarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/polymorphic_xml_woarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -28,7 +28,7 @@ namespace boost { namespace archive { typedef detail::polymorphic_oarchive_route< - xml_woarchive_impl + xml_woarchive_impl > polymorphic_xml_woarchive; } // namespace archive diff --git a/src/thirdparty/boost_lib/boost/archive/shared_ptr_helper.hpp b/src/thirdparty/boost_lib/boost/archive/shared_ptr_helper.hpp index 39e6eb82c..3df460555 100644 --- a/src/thirdparty/boost_lib/boost/archive/shared_ptr_helper.hpp +++ b/src/thirdparty/boost_lib/boost/archive/shared_ptr_helper.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/text_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/text_iarchive.hpp index 298928b3e..1fd0f608d 100644 --- a/src/thirdparty/boost_lib/boost/archive/text_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/text_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -35,6 +35,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + template class text_iarchive_impl : public basic_text_iprimitive, @@ -43,10 +47,16 @@ class text_iarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive; - friend class basic_text_iarchive; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + friend load_access; + #else + friend class detail::interface_iarchive; + friend class load_access; + #endif #endif template void load(T & t){ @@ -92,22 +102,6 @@ class text_iarchive_impl : ~text_iarchive_impl(){}; }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as text_iarchive below - without the shared_ptr_helper -class naked_text_iarchive : - public text_iarchive_impl -{ -public: - naked_text_iarchive(std::istream & is_, unsigned int flags = 0) : - // note: added _ to suppress useless gcc warning - text_iarchive_impl(is_, flags) - {} - ~naked_text_iarchive(){} -}; - } // namespace archive } // namespace boost @@ -117,12 +111,6 @@ class naked_text_iarchive : #include // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) @@ -132,9 +120,7 @@ namespace boost { namespace archive { class text_iarchive : - public text_iarchive_impl, - public detail::shared_ptr_helper -{ + public text_iarchive_impl{ public: text_iarchive(std::istream & is_, unsigned int flags = 0) : // note: added _ to suppress useless gcc warning diff --git a/src/thirdparty/boost_lib/boost/archive/text_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/text_oarchive.hpp index 2100d539e..9fd63a9b9 100644 --- a/src/thirdparty/boost_lib/boost/archive/text_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/text_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -42,6 +42,10 @@ namespace std{ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + template class text_oarchive_impl : /* protected ? */ public basic_text_oprimitive, @@ -50,10 +54,18 @@ class text_oarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive; - friend class basic_text_oarchive; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + friend basic_text_oarchive; + friend save_access; + #else + friend class detail::interface_oarchive; + friend class basic_text_oarchive; + friend class save_access; + #endif #endif template void save(const T & t){ @@ -102,8 +114,6 @@ class text_oarchive : ~text_oarchive(){} }; -typedef text_oarchive naked_text_oarchive; - } // namespace archive } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/archive/text_wiarchive.hpp b/src/thirdparty/boost_lib/boost/archive/text_wiarchive.hpp index 7451f3a62..5105d351c 100644 --- a/src/thirdparty/boost_lib/boost/archive/text_wiarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/text_wiarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -39,6 +39,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + template class text_wiarchive_impl : public basic_text_iprimitive, @@ -47,10 +51,16 @@ class text_wiarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive; - friend class basic_text_iarchive; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + friend load_access; + #else + friend class detail::interface_iarchive; + friend class load_access; + #endif #endif template void load(T & t){ @@ -89,21 +99,6 @@ class text_wiarchive_impl : ~text_wiarchive_impl(){}; }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as text_wiarchive below - without the shared_ptr_helper -class naked_text_wiarchive : - public text_wiarchive_impl -{ -public: - naked_text_wiarchive(std::wistream & is, unsigned int flags = 0) : - text_wiarchive_impl(is, flags) - {} - ~naked_text_wiarchive(){} -}; - } // namespace archive } // namespace boost @@ -113,12 +108,6 @@ class naked_text_wiarchive : #include // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) @@ -128,9 +117,7 @@ namespace boost { namespace archive { class text_wiarchive : - public text_wiarchive_impl, - public detail::shared_ptr_helper -{ + public text_wiarchive_impl{ public: text_wiarchive(std::wistream & is, unsigned int flags = 0) : text_wiarchive_impl(is, flags) diff --git a/src/thirdparty/boost_lib/boost/archive/text_woarchive.hpp b/src/thirdparty/boost_lib/boost/archive/text_woarchive.hpp index 7ed0c820b..2f75204d2 100644 --- a/src/thirdparty/boost_lib/boost/archive/text_woarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/text_woarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -47,6 +47,10 @@ namespace std{ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + template class text_woarchive_impl : public basic_text_oprimitive, @@ -55,10 +59,18 @@ class text_woarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive; - friend class basic_text_oarchive; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + friend basic_text_oarchive; + friend save_access; + #else + friend class detail::interface_oarchive; + friend class basic_text_oarchive; + friend class save_access; + #endif #endif template void save(const T & t){ @@ -127,8 +139,6 @@ class text_woarchive : ~text_woarchive(){} }; -typedef text_woarchive naked_text_woarchive; - } // namespace archive } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/archive/tmpdir.hpp b/src/thirdparty/boost_lib/boost/archive/tmpdir.hpp index 9e6ada4ce..400d23b9f 100644 --- a/src/thirdparty/boost_lib/boost/archive/tmpdir.hpp +++ b/src/thirdparty/boost_lib/boost/archive/tmpdir.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_TMPDIR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/wcslen.hpp b/src/thirdparty/boost_lib/boost/archive/wcslen.hpp index 5c14acfff..2a3d6351d 100644 --- a/src/thirdparty/boost_lib/boost/archive/wcslen.hpp +++ b/src/thirdparty/boost_lib/boost/archive/wcslen.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_WCSLEN_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/xml_archive_exception.hpp b/src/thirdparty/boost_lib/boost/archive/xml_archive_exception.hpp index 48e6cb329..622cafea4 100644 --- a/src/thirdparty/boost_lib/boost/archive/xml_archive_exception.hpp +++ b/src/thirdparty/boost_lib/boost/archive/xml_archive_exception.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/archive/xml_iarchive.hpp b/src/thirdparty/boost_lib/boost/archive/xml_iarchive.hpp index be6cfe494..ba50d7cc4 100644 --- a/src/thirdparty/boost_lib/boost/archive/xml_iarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/xml_iarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_XML_IARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -35,6 +35,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + template class basic_xml_grammar; typedef basic_xml_grammar xml_grammar; @@ -47,10 +51,18 @@ class xml_iarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive; - friend class basic_xml_iarchive; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + friend basic_xml_iarchive; + friend load_access; + #else + friend class detail::interface_iarchive; + friend class basic_xml_iarchive; + friend class load_access; + #endif #endif // instances of micro xml parser to parse start preambles // scoped_ptr doesn't play nice with borland - so use a naked pointer @@ -102,21 +114,6 @@ class xml_iarchive_impl : ~xml_iarchive_impl(); }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from text_iarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as xml_iarchive below - without the shared_ptr_helper -class naked_xml_iarchive : - public xml_iarchive_impl -{ -public: - naked_xml_iarchive(std::istream & is, unsigned int flags = 0) : - xml_iarchive_impl(is, flags) - {} - ~naked_xml_iarchive(){} -}; - } // namespace archive } // namespace boost @@ -125,13 +122,6 @@ class naked_xml_iarchive : #endif #include // pops abi_suffix.hpp pragmas - -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) @@ -141,9 +131,7 @@ namespace boost { namespace archive { class xml_iarchive : - public xml_iarchive_impl, - public detail::shared_ptr_helper -{ + public xml_iarchive_impl{ public: xml_iarchive(std::istream & is, unsigned int flags = 0) : xml_iarchive_impl(is, flags) diff --git a/src/thirdparty/boost_lib/boost/archive/xml_oarchive.hpp b/src/thirdparty/boost_lib/boost/archive/xml_oarchive.hpp index 167ba0937..2ac4ae1d6 100644 --- a/src/thirdparty/boost_lib/boost/archive/xml_oarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/xml_oarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_XML_OARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -42,6 +42,10 @@ namespace std{ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + template class xml_oarchive_impl : public basic_text_oprimitive, @@ -50,10 +54,18 @@ class xml_oarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive; - friend class basic_xml_oarchive; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + friend basic_xml_oarchive; + friend save_access; + #else + friend class detail::interface_oarchive; + friend class basic_xml_oarchive; + friend class save_access; + #endif #endif //void end_preamble(){ // basic_xml_oarchive::end_preamble(); @@ -116,8 +128,6 @@ class xml_oarchive : ~xml_oarchive(){} }; -typedef xml_oarchive naked_xml_oarchive; - } // namespace archive } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/archive/xml_wiarchive.hpp b/src/thirdparty/boost_lib/boost/archive/xml_wiarchive.hpp index 59ebbb5e7..31aff88ad 100644 --- a/src/thirdparty/boost_lib/boost/archive/xml_wiarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/xml_wiarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_XML_WIARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -40,6 +40,10 @@ namespace boost { namespace archive { +namespace detail { + template class interface_iarchive; +} // namespace detail + template class basic_xml_grammar; typedef basic_xml_grammar xml_wgrammar; @@ -52,10 +56,18 @@ class xml_wiarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_iarchive; - friend class basic_xml_iarchive; - friend class load_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_iarchive; + friend basic_xml_iarchive; + friend load_access; + #else + friend class detail::interface_iarchive; + friend class basic_xml_iarchive; + friend class load_access; + #endif #endif // instances of micro xml parser to parse start preambles // scoped_ptr doesn't play nice with borland - so use a naked pointer @@ -107,21 +119,6 @@ class xml_wiarchive_impl : ~xml_wiarchive_impl(); }; -// do not derive from the classes below. If you want to extend this functionality -// via inhertance, derived from xml_wiarchive_impl instead. This will -// preserve correct static polymorphism. - -// same as xml_wiarchive below - without the shared_ptr_helper -class naked_xml_wiarchive : - public xml_wiarchive_impl -{ -public: - naked_xml_wiarchive(std::wistream & is, unsigned int flags = 0) : - xml_wiarchive_impl(is, flags) - {} - ~naked_xml_wiarchive(){} -}; - } // namespace archive } // namespace boost @@ -131,12 +128,6 @@ class naked_xml_wiarchive : #include // pops abi_suffix.hpp pragmas -// note special treatment of shared_ptr. This type needs a special -// structure associated with every archive. We created a "mix-in" -// class to provide this functionality. Since shared_ptr holds a -// special esteem in the boost library - we included it here by default. -#include - #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4511 4512) @@ -146,9 +137,7 @@ namespace boost { namespace archive { class xml_wiarchive : - public xml_wiarchive_impl, - public detail::shared_ptr_helper -{ + public xml_wiarchive_impl{ public: xml_wiarchive(std::wistream & is, unsigned int flags = 0) : xml_wiarchive_impl(is, flags) diff --git a/src/thirdparty/boost_lib/boost/archive/xml_woarchive.hpp b/src/thirdparty/boost_lib/boost/archive/xml_woarchive.hpp index 08c0fdc6a..7fcaeb963 100644 --- a/src/thirdparty/boost_lib/boost/archive/xml_woarchive.hpp +++ b/src/thirdparty/boost_lib/boost/archive/xml_woarchive.hpp @@ -2,7 +2,7 @@ #define BOOST_ARCHIVE_XML_WOARCHIVE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -46,6 +46,10 @@ namespace std{ namespace boost { namespace archive { +namespace detail { + template class interface_oarchive; +} // namespace detail + template class xml_woarchive_impl : public basic_text_oprimitive, @@ -54,11 +58,20 @@ class xml_woarchive_impl : #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS public: #else - friend class detail::interface_oarchive; - friend class basic_xml_oarchive; - friend class save_access; protected: + #if BOOST_WORKAROUND(BOOST_MSVC, < 1500) + // for some inexplicable reason insertion of "class" generates compile erro + // on msvc 7.1 + friend detail::interface_oarchive; + friend basic_xml_oarchive; + friend save_access; + #else + friend class detail::interface_oarchive; + friend class basic_xml_oarchive; + friend class save_access; + #endif #endif + //void end_preamble(){ // basic_xml_oarchive::end_preamble(); //} @@ -122,8 +135,6 @@ class xml_woarchive : ~xml_woarchive(){} }; -typedef xml_woarchive naked_xml_woarchive; - } // namespace archive } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/asio.hpp b/src/thirdparty/boost_lib/boost/asio.hpp index a810967cc..871fcbe41 100644 --- a/src/thirdparty/boost_lib/boost/asio.hpp +++ b/src/thirdparty/boost_lib/boost/asio.hpp @@ -2,7 +2,7 @@ // asio.hpp // ~~~~~~~~ // -// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/src/thirdparty/boost_lib/boost/assert.hpp b/src/thirdparty/boost_lib/boost/assert.hpp index ccc776a43..1713d9bb1 100644 --- a/src/thirdparty/boost_lib/boost/assert.hpp +++ b/src/thirdparty/boost_lib/boost/assert.hpp @@ -2,18 +2,19 @@ // boost/assert.hpp - BOOST_ASSERT(expr) // BOOST_ASSERT_MSG(expr, msg) // BOOST_VERIFY(expr) +// BOOST_VERIFY_MSG(expr, msg) // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. -// Copyright (c) 2007 Peter Dimov +// Copyright (c) 2007, 2014 Peter Dimov // Copyright (c) Beman Dawes 2011 // -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) +// 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 // // Note: There are no include guards. This is intentional. // -// See http://www.boost.org/libs/utility/assert.html for documentation. +// See http://www.boost.org/libs/assert/assert.html for documentation. // // @@ -22,120 +23,56 @@ // boostinspect:naassert_macro // -//--------------------------------------------------------------------------------------// -// BOOST_ASSERT // -//--------------------------------------------------------------------------------------// +// +// BOOST_ASSERT, BOOST_ASSERT_MSG +// #undef BOOST_ASSERT +#undef BOOST_ASSERT_MSG -#if defined(BOOST_DISABLE_ASSERTS) +#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) ) # define BOOST_ASSERT(expr) ((void)0) +# define BOOST_ASSERT_MSG(expr, msg) ((void)0) -#elif defined(BOOST_ENABLE_ASSERT_HANDLER) +#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) ) -#include +#include // for BOOST_LIKELY #include namespace boost { - void assertion_failed(char const * expr, - char const * function, char const * file, long line); // user defined + void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined + void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined } // namespace boost -#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr)) \ - ? ((void)0) \ - : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) +#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) +#define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) #else -# include // .h to support old libraries w/o - effect is the same -# define BOOST_ASSERT(expr) assert(expr) -#endif - -//--------------------------------------------------------------------------------------// -// BOOST_ASSERT_MSG // -//--------------------------------------------------------------------------------------// - -# undef BOOST_ASSERT_MSG - -#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG) - - #define BOOST_ASSERT_MSG(expr, msg) ((void)0) -#elif defined(BOOST_ENABLE_ASSERT_HANDLER) - - #include - #include - - namespace boost - { - void assertion_failed_msg(char const * expr, char const * msg, - char const * function, char const * file, long line); // user defined - } // namespace boost +# include // .h to support old libraries w/o - effect is the same - #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \ - ? ((void)0) \ - : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) +# define BOOST_ASSERT(expr) assert(expr) +# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) -#else - #ifndef BOOST_ASSERT_HPP - #define BOOST_ASSERT_HPP - #include - #include - #include - #include - - // IDE's like Visual Studio perform better if output goes to std::cout or - // some other stream, so allow user to configure output stream: - #ifndef BOOST_ASSERT_MSG_OSTREAM - # define BOOST_ASSERT_MSG_OSTREAM std::cerr - #endif - - namespace boost - { - namespace assertion - { - namespace detail - { - // Note: The template is needed to make the function non-inline and avoid linking errors - template< typename CharT > - BOOST_NOINLINE void assertion_failed_msg(CharT const * expr, char const * msg, char const * function, - char const * file, long line) - { - BOOST_ASSERT_MSG_OSTREAM - << "***** Internal Program Error - assertion (" << expr << ") failed in " - << function << ":\n" - << file << '(' << line << "): " << msg << std::endl; -#ifdef UNDER_CE - // The Windows CE CRT library does not have abort() so use exit(-1) instead. - std::exit(-1); -#else - std::abort(); -#endif - } - } // detail - } // assertion - } // detail - #endif - - #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \ - ? ((void)0) \ - : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \ - BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) #endif -//--------------------------------------------------------------------------------------// -// BOOST_VERIFY // -//--------------------------------------------------------------------------------------// +// +// BOOST_VERIFY, BOOST_VERIFY_MSG +// #undef BOOST_VERIFY +#undef BOOST_VERIFY_MSG #if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) ) # define BOOST_VERIFY(expr) ((void)(expr)) +# define BOOST_VERIFY_MSG(expr, msg) ((void)(expr)) #else # define BOOST_VERIFY(expr) BOOST_ASSERT(expr) +# define BOOST_VERIFY_MSG(expr, msg) BOOST_ASSERT_MSG(expr,msg) #endif diff --git a/src/thirdparty/boost_lib/boost/assign.hpp b/src/thirdparty/boost_lib/boost/assign.hpp index d74a56601..fffb7ecee 100644 --- a/src/thirdparty/boost_lib/boost/assign.hpp +++ b/src/thirdparty/boost_lib/boost/assign.hpp @@ -12,7 +12,7 @@ #ifndef BOOST_ASSIGN_HPP #define BOOST_ASSIGN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/bind/arg.hpp b/src/thirdparty/boost_lib/boost/bind/arg.hpp index 0d5cd03a7..c879bb408 100644 --- a/src/thirdparty/boost_lib/boost/bind/arg.hpp +++ b/src/thirdparty/boost_lib/boost/bind/arg.hpp @@ -21,6 +21,7 @@ #include #include +#include namespace boost { @@ -33,8 +34,7 @@ template< int I > struct arg template< class T > arg( T const & /* t */ ) { - // static assert I == is_placeholder::value - typedef char T_must_be_placeholder[ I == is_placeholder::value? 1: -1 ]; + BOOST_STATIC_ASSERT( I == is_placeholder::value ); } }; diff --git a/src/thirdparty/boost_lib/boost/call_traits.hpp b/src/thirdparty/boost_lib/boost/call_traits.hpp index 5253a6de5..2c1328e94 100644 --- a/src/thirdparty/boost_lib/boost/call_traits.hpp +++ b/src/thirdparty/boost_lib/boost/call_traits.hpp @@ -5,7 +5,7 @@ // // See http://www.boost.org/libs/utility for most recent version including documentation. -// See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp +// See boost/detail/call_traits.hpp // for full copyright notices. #ifndef BOOST_CALL_TRAITS_HPP @@ -15,10 +15,6 @@ #include #endif -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#else #include -#endif #endif // BOOST_CALL_TRAITS_HPP diff --git a/src/thirdparty/boost_lib/boost/cast.hpp b/src/thirdparty/boost_lib/boost/cast.hpp index 2615d183f..ab452bdf1 100644 --- a/src/thirdparty/boost_lib/boost/cast.hpp +++ b/src/thirdparty/boost_lib/boost/cast.hpp @@ -1,107 +1,20 @@ -// boost cast.hpp header file ----------------------------------------------// - -// (C) Copyright Kevlin Henney and Dave Abrahams 1999. +// boost cast.hpp header file +// +// (C) Copyright Antony Polukhin 2014. +// // 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/conversion for Documentation. -// Revision History -// 23 JUn 05 numeric_cast removed and redirected to the new verion (Fernando Cacciola) -// 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included -// instead (the workaround did not -// actually compile when BOOST_NO_LIMITS was defined in -// any case, so we loose nothing). (John Maddock) -// 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never -// worked with stock GCC; trying to get it to do that broke -// vc-stlport. -// 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp. -// Removed unused BOOST_EXPLICIT_TARGET macro. Moved -// boost::detail::type to boost/type.hpp. Made it compile with -// stock gcc again (Dave Abrahams) -// 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal -// Review (Beman Dawes) -// 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams) -// 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC -// (Dave Abrahams) -// 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams) -// 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes) -// 27 Jun 00 More MSVC6 workarounds -// 15 Jun 00 Add workarounds for MSVC6 -// 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov) -// 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar) -// 29 Dec 99 Change using declarations so usages in other namespaces work -// correctly (Dave Abrahams) -// 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors -// as suggested Darin Adler and improved by Valentin Bonnard. -// 2 Sep 99 Remove controversial asserts, simplify, rename. -// 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast, -// place in nested namespace. -// 3 Aug 99 Initial version +// This is a DEPRECATED header file! +// Use or instead #ifndef BOOST_CAST_HPP #define BOOST_CAST_HPP -# include -# include -# include -# include -# include -# include - -// It has been demonstrated numerous times that MSVC 6.0 fails silently at link -// time if you use a template function which has template parameters that don't -// appear in the function's argument list. -// -// TODO: Add this to config.hpp? -# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 -# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type* = 0 -# else -# define BOOST_EXPLICIT_DEFAULT_TARGET -# endif - -namespace boost -{ -// See the documentation for descriptions of how to choose between -// static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<> - -// polymorphic_cast --------------------------------------------------------// - - // Runtime checked polymorphic downcasts and crosscasts. - // Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup, - // section 15.8 exercise 1, page 425. - - template - inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET) - { - Target tmp = dynamic_cast(x); - if ( tmp == 0 ) throw std::bad_cast(); - return tmp; - } - -// polymorphic_downcast ----------------------------------------------------// - - // BOOST_ASSERT() checked polymorphic downcast. Crosscasts prohibited. - - // WARNING: Because this cast uses BOOST_ASSERT(), it violates - // the One Definition Rule if used in multiple translation units - // where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER - // NDEBUG are defined inconsistently. - - // Contributed by Dave Abrahams - - template - inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET) - { - BOOST_ASSERT( dynamic_cast(x) == x ); // detect logic error - return static_cast(x); - } - -# undef BOOST_EXPLICIT_DEFAULT_TARGET - -} // namespace boost - +# include # include #endif // BOOST_CAST_HPP diff --git a/src/thirdparty/boost_lib/boost/checked_delete.hpp b/src/thirdparty/boost_lib/boost/checked_delete.hpp index 9bb84e8e1..fb71c789c 100644 --- a/src/thirdparty/boost_lib/boost/checked_delete.hpp +++ b/src/thirdparty/boost_lib/boost/checked_delete.hpp @@ -1,69 +1,17 @@ -#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED -#define BOOST_CHECKED_DELETE_HPP_INCLUDED +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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) + */ -// MS compatible compilers support #pragma once +#ifndef BOOST_CHECKED_DELETE_HPP +#define BOOST_CHECKED_DELETE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -// -// boost/checked_delete.hpp -// -// Copyright (c) 2002, 2003 Peter Dimov -// Copyright (c) 2003 Daniel Frey -// Copyright (c) 2003 Howard Hinnant -// -// 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/utility/checked_delete.html for documentation. -// - -namespace boost -{ - -// verify that types are complete for increased safety - -template inline void checked_delete(T * x) -{ - // intentionally complex - simplification causes regressions - typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; - (void) sizeof(type_must_be_complete); - delete x; -} - -template inline void checked_array_delete(T * x) -{ - typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; - (void) sizeof(type_must_be_complete); - delete [] x; -} +// The header file at this path is deprecated; +// use boost/core/checked_delete.hpp instead. -template struct checked_deleter -{ - typedef void result_type; - typedef T * argument_type; +#include - void operator()(T * x) const - { - // boost:: disables ADL - boost::checked_delete(x); - } -}; - -template struct checked_array_deleter -{ - typedef void result_type; - typedef T * argument_type; - - void operator()(T * x) const - { - boost::checked_array_delete(x); - } -}; - -} // namespace boost - -#endif // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED +#endif diff --git a/src/thirdparty/boost_lib/boost/circular_buffer.hpp b/src/thirdparty/boost_lib/boost/circular_buffer.hpp index 13cc94fef..f5eff60f0 100644 --- a/src/thirdparty/boost_lib/boost/circular_buffer.hpp +++ b/src/thirdparty/boost_lib/boost/circular_buffer.hpp @@ -11,12 +11,13 @@ #if !defined(BOOST_CIRCULAR_BUFFER_HPP) #define BOOST_CIRCULAR_BUFFER_HPP -#if defined(_MSC_VER) && _MSC_VER >= 1200 +#if defined(_MSC_VER) #pragma once #endif #include #include +#include // BOOST_CB_ENABLE_DEBUG: Debug support control. #if defined(NDEBUG) || defined(BOOST_CB_DISABLE_DEBUG) @@ -33,29 +34,20 @@ #define BOOST_CB_ASSERT(Expr) ((void)0) #endif -// BOOST_CB_STATIC_ASSERT: Compile time assertion. -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - #define BOOST_CB_STATIC_ASSERT(Expr) ((void)0) -#else - #include - #define BOOST_CB_STATIC_ASSERT(Expr) BOOST_STATIC_ASSERT(Expr) -#endif - // BOOST_CB_IS_CONVERTIBLE: Check if Iterator::value_type is convertible to Type. -#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407) || \ - BOOST_WORKAROUND(BOOST_MSVC, < 1300) +#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407) #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) ((void)0) #else #include #include #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) \ - BOOST_CB_STATIC_ASSERT((is_convertible::value_type, Type>::value)) + BOOST_STATIC_ASSERT((is_convertible::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_CB_STATIC_ASSERT(false); + #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS BOOST_STATIC_ASSERT(false); #else #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS ((void)0); #endif @@ -67,7 +59,6 @@ #undef BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS #undef BOOST_CB_IS_CONVERTIBLE -#undef BOOST_CB_STATIC_ASSERT #undef BOOST_CB_ASSERT #undef BOOST_CB_ENABLE_DEBUG diff --git a/src/thirdparty/boost_lib/boost/compressed_pair.hpp b/src/thirdparty/boost_lib/boost/compressed_pair.hpp index e6cd6a074..a7be0f2ba 100644 --- a/src/thirdparty/boost_lib/boost/compressed_pair.hpp +++ b/src/thirdparty/boost_lib/boost/compressed_pair.hpp @@ -5,7 +5,7 @@ // // See http://www.boost.org/libs/utility for most recent version including documentation. -// See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp +// See boost/detail/compressed_pair.hpp // for full copyright notices. #ifndef BOOST_COMPRESSED_PAIR_HPP @@ -15,10 +15,6 @@ #include #endif -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#else #include -#endif #endif // BOOST_COMPRESSED_PAIR_HPP diff --git a/src/thirdparty/boost_lib/boost/concept_check.hpp b/src/thirdparty/boost_lib/boost/concept_check.hpp index bf5a2af78..292f37d3b 100644 --- a/src/thirdparty/boost_lib/boost/concept_check.hpp +++ b/src/thirdparty/boost_lib/boost/concept_check.hpp @@ -32,6 +32,12 @@ # include # include +#if (defined _MSC_VER) +# pragma warning( push ) +# pragma warning( disable : 4510 ) // default constructor could not be generated +# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required +#endif + namespace boost { @@ -175,11 +181,6 @@ namespace boost TT b; }; -#if (defined _MSC_VER) -# pragma warning( push ) -# pragma warning( disable : 4510 ) // default constructor could not be generated -# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required -#endif // The SGI STL version of Assignable requires copy constructor and operator= BOOST_concept(SGIAssignable,(TT)) { @@ -202,9 +203,6 @@ namespace boost TT a; TT b; }; -#if (defined _MSC_VER) -# pragma warning( pop ) -#endif BOOST_concept(Convertible,(X)(Y)) { @@ -562,10 +560,10 @@ namespace boost : ForwardIterator { BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) { - *i++ = *i; // require postincrement and assignment + *i++ = *j; // require postincrement and assignment } private: - TT i; + TT i, j; }; BOOST_concept(BidirectionalIterator,(TT)) @@ -591,10 +589,10 @@ namespace boost { BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator) { - *i-- = *i; // require postdecrement and assignment + *i-- = *j; // require postdecrement and assignment } private: - TT i; + TT i, j; }; BOOST_concept(RandomAccessIterator,(TT)) @@ -880,7 +878,7 @@ namespace boost typename BackInsertionSequence::const_reference r = cc.back(); ignore_unused_variable_warning(r); - }; + } S c; typename S::value_type t; }; @@ -1077,6 +1075,10 @@ namespace boost }; } // namespace boost +#if (defined _MSC_VER) +# pragma warning( pop ) +#endif + # include #endif // BOOST_CONCEPT_CHECKS_HPP diff --git a/src/thirdparty/boost_lib/boost/config.hpp b/src/thirdparty/boost_lib/boost/config.hpp index 6ec3645c2..d49bb27cd 100644 --- a/src/thirdparty/boost_lib/boost/config.hpp +++ b/src/thirdparty/boost_lib/boost/config.hpp @@ -20,6 +20,10 @@ // if we don't have a user config, then use the default location: #if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG) # define BOOST_USER_CONFIG +#if 0 +// For dependency trackers: +# include +#endif #endif // include it first: #ifdef BOOST_USER_CONFIG diff --git a/src/thirdparty/boost_lib/boost/config/compiler/borland.hpp b/src/thirdparty/boost_lib/boost/config/compiler/borland.hpp index a8f5baaeb..d2a09024d 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/borland.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/borland.hpp @@ -194,6 +194,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS #if __BORLANDC__ >= 0x590 # define BOOST_HAS_TR1_HASH diff --git a/src/thirdparty/boost_lib/boost/config/compiler/clang.hpp b/src/thirdparty/boost_lib/boost/config/compiler/clang.hpp index b57e26c5a..6a178242d 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/clang.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/clang.hpp @@ -10,6 +10,14 @@ #define BOOST_HAS_PRAGMA_ONCE +// When compiling with clang before __has_extension was defined, +// even if one writes 'defined(__has_extension) && __has_extension(xxx)', +// clang reports a compiler error. So the only workaround found is: + +#ifndef __has_extension +#define __has_extension __has_feature +#endif + #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS) # define BOOST_NO_EXCEPTIONS #endif @@ -39,6 +47,11 @@ // Clang supports "long long" in all compilation modes. #define BOOST_HAS_LONG_LONG +#if defined(__SIZEOF_INT128__) +# define BOOST_HAS_INT128 +#endif + + // // Dynamic shared object (DSO) and dynamic-link library (DLL) support // @@ -63,7 +76,10 @@ # define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS #endif -#if !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) +// +// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t +// +#if defined(_MSC_VER) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) # define BOOST_NO_CXX11_CHAR16_T # define BOOST_NO_CXX11_CHAR32_T #endif @@ -124,6 +140,10 @@ # define BOOST_NO_CXX11_RAW_LITERALS #endif +#if !__has_feature(cxx_reference_qualified_functions) +# define BOOST_NO_CXX11_REF_QUALIFIERS +#endif + #if !__has_feature(cxx_generalized_initializers) # define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX #endif diff --git a/src/thirdparty/boost_lib/boost/config/compiler/codegear.hpp b/src/thirdparty/boost_lib/boost/config/compiler/codegear.hpp index 00e0bb949..6b52282f6 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/codegear.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/codegear.hpp @@ -120,6 +120,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS // // TR1 macros: diff --git a/src/thirdparty/boost_lib/boost/config/compiler/common_edg.hpp b/src/thirdparty/boost_lib/boost/config/compiler/common_edg.hpp index 70e7efa2e..d5589adde 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/common_edg.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/common_edg.hpp @@ -104,6 +104,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS #ifdef c_plusplus // EDG has "long long" in non-strict mode diff --git a/src/thirdparty/boost_lib/boost/config/compiler/cray.hpp b/src/thirdparty/boost_lib/boost/config/compiler/cray.hpp index 3ce29f011..94e932b8d 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/cray.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/cray.hpp @@ -1,4 +1,5 @@ // (C) Copyright John Maddock 2011. +// (C) Copyright Cray, Inc. 2013 // 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) @@ -9,8 +10,8 @@ #define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE) -#if _RELEASE < 7 -# error "Boost is not configured for Cray compilers prior to version 7, please try the configure script." +#if _RELEASE < 8 +# error "Boost is not configured for Cray compilers prior to version 8, please try the configure script." #endif // @@ -22,12 +23,14 @@ #include "boost/config/compiler/common_edg.hpp" + // -// Cray peculiarities, probably version 7 specific: // -#undef BOOST_NO_CXX11_AUTO_DECLARATIONS -#undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS +#define BOOST_NO_CXX11_STATIC_ASSERT +#define BOOST_NO_CXX11_AUTO_DECLARATIONS +#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS #define BOOST_HAS_NRVO +#define BOOST_NO_CXX11_VARIADIC_MACROS #define BOOST_NO_CXX11_VARIADIC_TEMPLATES #define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX #define BOOST_NO_CXX11_UNICODE_LITERALS @@ -55,11 +58,32 @@ #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION #define BOOST_NO_CXX11_CHAR32_T #define BOOST_NO_CXX11_CHAR16_T -#define BOOST_NO_CXX11_ALIGNAS +#define BOOST_NO_CXX11_REF_QUALIFIERS //#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG #define BOOST_MATH_DISABLE_STD_FPCLASSIFY //#define BOOST_HAS_FPCLASSIFY -#define BOOST_SP_USE_PTHREADS -#define BOOST_AC_USE_PTHREADS +#define BOOST_SP_USE_PTHREADS +#define BOOST_AC_USE_PTHREADS + +/* everything that follows is working around what are thought to be + * compiler shortcomings. Revist all of these regularly. + */ + +//#define BOOST_USE_ENUM_STATIC_ASSERT +//#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS //(this may be implied by the previous #define + +// These constants should be provided by the +// compiler, at least when -hgnu is asserted on the command line. + +#ifndef __ATOMIC_RELAXED +#define __ATOMIC_RELAXED 0 +#define __ATOMIC_CONSUME 1 +#define __ATOMIC_ACQUIRE 2 +#define __ATOMIC_RELEASE 3 +#define __ATOMIC_ACQ_REL 4 +#define __ATOMIC_SEQ_CST 5 +#endif + + diff --git a/src/thirdparty/boost_lib/boost/config/compiler/digitalmars.hpp b/src/thirdparty/boost_lib/boost/config/compiler/digitalmars.hpp index 7de6adb10..7bc49ab4b 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/digitalmars.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/digitalmars.hpp @@ -80,6 +80,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS #if (__DMC__ <= 0x840) #error "Compiler not supported or configured - please reconfigure" diff --git a/src/thirdparty/boost_lib/boost/config/compiler/gcc.hpp b/src/thirdparty/boost_lib/boost/config/compiler/gcc.hpp index aa628e5a7..ef6b07e27 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/gcc.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/gcc.hpp @@ -74,8 +74,12 @@ // // gcc has "long long" +// Except on Darwin with standard compliance enabled (-pedantic) +// Apple gcc helpfully defines this macro we can query // -#define BOOST_HAS_LONG_LONG +#if !defined(__DARWIN_NO_LONG_LONG) +# define BOOST_HAS_LONG_LONG +#endif // // gcc implements the named return value optimization since version 3.1 @@ -228,6 +232,7 @@ // #if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40801) || !defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_NO_CXX11_DECLTYPE_N3276 +# define BOOST_NO_CXX11_REF_QUALIFIERS #endif #ifndef BOOST_COMPILER diff --git a/src/thirdparty/boost_lib/boost/config/compiler/gcc_xml.hpp b/src/thirdparty/boost_lib/boost/config/compiler/gcc_xml.hpp index d2e0c74f8..f04af0618 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/gcc_xml.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/gcc_xml.hpp @@ -58,6 +58,7 @@ # define BOOST_NO_CXX11_ALIGNAS # define BOOST_NO_CXX11_TRAILING_RESULT_TYPES # define BOOST_NO_CXX11_INLINE_NAMESPACES +# define BOOST_NO_CXX11_REF_QUALIFIERS #define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__ diff --git a/src/thirdparty/boost_lib/boost/config/compiler/hp_acc.hpp b/src/thirdparty/boost_lib/boost/config/compiler/hp_acc.hpp index f08dca44a..fb63839a5 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/hp_acc.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/hp_acc.hpp @@ -122,6 +122,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS /* See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and diff --git a/src/thirdparty/boost_lib/boost/config/compiler/intel.hpp b/src/thirdparty/boost_lib/boost/config/compiler/intel.hpp index 3f0eaa18d..cbc9422f6 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/intel.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/intel.hpp @@ -265,6 +265,7 @@ template<> struct assert_intrinsic_wchar_t {}; # undef BOOST_NO_CXX11_HDR_THREAD # undef BOOST_NO_CXX11_CHAR32_T # undef BOOST_NO_CXX11_CHAR16_T +# undef BOOST_NO_CXX11_REF_QUALIFIERS #endif #if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION <= 1310) diff --git a/src/thirdparty/boost_lib/boost/config/compiler/metrowerks.hpp b/src/thirdparty/boost_lib/boost/config/compiler/metrowerks.hpp index e17278607..c000215bb 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/metrowerks.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/metrowerks.hpp @@ -123,6 +123,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) diff --git a/src/thirdparty/boost_lib/boost/config/compiler/mpw.hpp b/src/thirdparty/boost_lib/boost/config/compiler/mpw.hpp index 69104674d..7a4ffa150 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/mpw.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/mpw.hpp @@ -72,7 +72,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES - +#define BOOST_NO_CXX11_REF_QUALIFIERS // // versions check: // we don't support MPW prior to version 8.9: diff --git a/src/thirdparty/boost_lib/boost/config/compiler/pathscale.hpp b/src/thirdparty/boost_lib/boost/config/compiler/pathscale.hpp index 567d83cc1..0625d7a1e 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/pathscale.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/pathscale.hpp @@ -80,4 +80,5 @@ # define BOOST_NO_CXX11_ALIGNAS # define BOOST_NO_CXX11_TRAILING_RESULT_TYPES # define BOOST_NO_CXX11_INLINE_NAMESPACES +# define BOOST_NO_CXX11_REF_QUALIFIERS #endif diff --git a/src/thirdparty/boost_lib/boost/config/compiler/pgi.hpp b/src/thirdparty/boost_lib/boost/config/compiler/pgi.hpp index d50cbef82..5cf61fa94 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/pgi.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/pgi.hpp @@ -118,6 +118,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS // // version check: diff --git a/src/thirdparty/boost_lib/boost/config/compiler/sunpro_cc.hpp b/src/thirdparty/boost_lib/boost/config/compiler/sunpro_cc.hpp index 486d5c432..f2c857629 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/sunpro_cc.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/sunpro_cc.hpp @@ -131,6 +131,7 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS // // Version diff --git a/src/thirdparty/boost_lib/boost/config/compiler/vacpp.hpp b/src/thirdparty/boost_lib/boost/config/compiler/vacpp.hpp index 17c02f910..bb7d5f506 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/vacpp.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/vacpp.hpp @@ -129,3 +129,4 @@ #define BOOST_NO_CXX11_ALIGNAS #define BOOST_NO_CXX11_TRAILING_RESULT_TYPES #define BOOST_NO_CXX11_INLINE_NAMESPACES +#define BOOST_NO_CXX11_REF_QUALIFIERS diff --git a/src/thirdparty/boost_lib/boost/config/compiler/visualc.hpp b/src/thirdparty/boost_lib/boost/config/compiler/visualc.hpp index 695fa9430..842f08651 100644 --- a/src/thirdparty/boost_lib/boost/config/compiler/visualc.hpp +++ b/src/thirdparty/boost_lib/boost/config/compiler/visualc.hpp @@ -57,11 +57,6 @@ # define BOOST_NO_CXX11_VARIADIC_MACROS #endif -#if defined(UNDER_CE) -// Windows CE does not have a conforming signature for swprintf -# define BOOST_NO_SWPRINTF -#endif - #if _MSC_VER < 1500 // 140X == VC++ 8.0 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS #endif @@ -91,16 +86,6 @@ # define BOOST_NO_INTRINSIC_WCHAR_T #endif -#if defined(_WIN32_WCE) || defined(UNDER_CE) -# define BOOST_NO_SWPRINTF -#endif - -// we have ThreadEx or GetSystemTimeAsFileTime unless we're running WindowsCE -#if !defined(_WIN32_WCE) && !defined(UNDER_CE) -# define BOOST_HAS_THREADEX -# define BOOST_HAS_GETSYSTEMTIMEASFILETIME -#endif - // // check for exception handling support: #if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS) @@ -120,7 +105,7 @@ # define BOOST_HAS_NRVO #endif // -// disable Win32 API's if compiler extentions are +// disable Win32 API's if compiler extensions are // turned off: // #if !defined(_MSC_EXTENSIONS) && !defined(BOOST_DISABLE_WIN32) @@ -180,14 +165,15 @@ # define BOOST_NO_CXX11_TRAILING_RESULT_TYPES # define BOOST_NO_CXX11_VARIADIC_TEMPLATES # define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX +# define BOOST_NO_CXX11_DECLTYPE_N3276 #endif // C++11 features not supported by any versions #define BOOST_NO_CXX11_CHAR16_T #define BOOST_NO_CXX11_CHAR32_T #define BOOST_NO_CXX11_CONSTEXPR -#define BOOST_NO_CXX11_DECLTYPE_N3276 #define BOOST_NO_CXX11_NOEXCEPT +#define BOOST_NO_CXX11_REF_QUALIFIERS #define BOOST_NO_CXX11_UNICODE_LITERALS #define BOOST_NO_SFINAE_EXPR #define BOOST_NO_TWO_PHASE_NAME_LOOKUP diff --git a/src/thirdparty/boost_lib/boost/config/platform/win32.hpp b/src/thirdparty/boost_lib/boost/config/platform/win32.hpp index 6ab59f4e9..2a91519e2 100644 --- a/src/thirdparty/boost_lib/boost/config/platform/win32.hpp +++ b/src/thirdparty/boost_lib/boost/config/platform/win32.hpp @@ -55,14 +55,21 @@ // all translation units (needed for shared_ptr etc). // -#ifdef _WIN32_WCE +#ifndef BOOST_HAS_PTHREADS +# define BOOST_HAS_WINTHREADS +#endif + +// +// WinCE configuration: +// +#if defined(_WIN32_WCE) || defined(UNDER_CE) # define BOOST_NO_ANSI_APIS +// Windows CE does not have a conforming signature for swprintf +# define BOOST_NO_SWPRINTF #else # define BOOST_HAS_GETSYSTEMTIMEASFILETIME -#endif - -#ifndef BOOST_HAS_PTHREADS -# define BOOST_HAS_WINTHREADS +# define BOOST_HAS_THREADEX +# define BOOST_HAS_GETSYSTEMTIMEASFILETIME #endif #ifndef BOOST_DISABLE_WIN32 diff --git a/src/thirdparty/boost_lib/boost/config/select_compiler_config.hpp b/src/thirdparty/boost_lib/boost/config/select_compiler_config.hpp index 0eeb7ad3e..62053ba06 100644 --- a/src/thirdparty/boost_lib/boost/config/select_compiler_config.hpp +++ b/src/thirdparty/boost_lib/boost/config/select_compiler_config.hpp @@ -112,3 +112,32 @@ # error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)" #endif + +#if 0 +// +// This section allows dependency scanners to find all the headers we *might* include: +// +#include "boost/config/compiler/gcc_xml.hpp" +#include "boost/config/compiler/cray.hpp" +#include "boost/config/compiler/comeau.hpp" +#include "boost/config/compiler/pathscale.hpp" +#include "boost/config/compiler/intel.hpp" +#include "boost/config/compiler/clang.hpp" +#include "boost/config/compiler/digitalmars.hpp" +#include "boost/config/compiler/gcc.hpp" +#include "boost/config/compiler/kai.hpp" +#include "boost/config/compiler/sgi_mipspro.hpp" +#include "boost/config/compiler/compaq_cxx.hpp" +#include "boost/config/compiler/greenhills.hpp" +#include "boost/config/compiler/codegear.hpp" +#include "boost/config/compiler/borland.hpp" +#include "boost/config/compiler/metrowerks.hpp" +#include "boost/config/compiler/sunpro_cc.hpp" +#include "boost/config/compiler/hp_acc.hpp" +#include "boost/config/compiler/mpw.hpp" +#include "boost/config/compiler/vacpp.hpp" +#include "boost/config/compiler/pgi.hpp" +#include "boost/config/compiler/visualc.hpp" + +#endif + diff --git a/src/thirdparty/boost_lib/boost/config/select_platform_config.hpp b/src/thirdparty/boost_lib/boost/config/select_platform_config.hpp index 2af61d2d4..2dddc6a2f 100644 --- a/src/thirdparty/boost_lib/boost/config/select_platform_config.hpp +++ b/src/thirdparty/boost_lib/boost/config/select_platform_config.hpp @@ -101,5 +101,29 @@ #endif +#if 0 +// +// This section allows dependency scanners to find all the files we *might* include: +// +# include "boost/config/platform/linux.hpp" +# include "boost/config/platform/bsd.hpp" +# include "boost/config/platform/solaris.hpp" +# include "boost/config/platform/irix.hpp" +# include "boost/config/platform/hpux.hpp" +# include "boost/config/platform/cygwin.hpp" +# include "boost/config/platform/win32.hpp" +# include "boost/config/platform/beos.hpp" +# include "boost/config/platform/macos.hpp" +# include "boost/config/platform/aix.hpp" +# include "boost/config/platform/amigaos.hpp" +# include "boost/config/platform/qnxnto.hpp" +# include "boost/config/platform/vxworks.hpp" +# include "boost/config/platform/symbian.hpp" +# include "boost/config/platform/cray.hpp" +# include "boost/config/platform/vms.hpp" +# include + +#endif + diff --git a/src/thirdparty/boost_lib/boost/config/select_stdlib_config.hpp b/src/thirdparty/boost_lib/boost/config/select_stdlib_config.hpp index 96ede0022..6ae860b02 100644 --- a/src/thirdparty/boost_lib/boost/config/select_stdlib_config.hpp +++ b/src/thirdparty/boost_lib/boost/config/select_stdlib_config.hpp @@ -81,5 +81,19 @@ #endif - +#if 0 +// +// This section allows dependency scanners to find all the files we *might* include: +// +# include "boost/config/stdlib/stlport.hpp" +# include "boost/config/stdlib/libcomo.hpp" +# include "boost/config/stdlib/roguewave.hpp" +# include "boost/config/stdlib/libcpp.hpp" +# include "boost/config/stdlib/libstdcpp3.hpp" +# include "boost/config/stdlib/sgi.hpp" +# include "boost/config/stdlib/msl.hpp" +# include "boost/config/stdlib/vacpp.hpp" +# include "boost/config/stdlib/modena.hpp" +# include "boost/config/stdlib/dinkumware.hpp" +#endif diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/dinkumware.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/dinkumware.hpp index a8b68be7e..6fb6322ac 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/dinkumware.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/dinkumware.hpp @@ -86,9 +86,18 @@ # define BOOST_NO_STD_LOCALE #endif +// Fix for VC++ 8.0 on up ( I do not have a previous version to test ) +// or clang-cl. If exceptions are off you must manually include the +// header before including the header. Admittedly +// trying to use Boost libraries or the standard C++ libraries without +// exception support is not suggested but currently clang-cl ( v 3.4 ) +// does not support exceptions and must be compiled with exceptions off. +#if !_HAS_EXCEPTIONS && ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER))) +#include +#endif #include #if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) && !defined(__TI_COMPILER_VERSION__) -# define BOOST_NO_STD_TYPEINFO +# define BOOST_NO_STD_TYPEINFO #endif // C++0x headers implemented in 520 (as shipped by Microsoft) @@ -125,7 +134,6 @@ # define BOOST_NO_CXX11_HDR_MUTEX # define BOOST_NO_CXX11_HDR_RATIO # define BOOST_NO_CXX11_HDR_THREAD -# define BOOST_NO_CXX11_ALLOCATOR # define BOOST_NO_CXX11_ATOMIC_SMART_PTR #endif @@ -133,8 +141,16 @@ // #if !defined(_CPPLIB_VER) || _CPPLIB_VER < 610 # define BOOST_NO_CXX11_HDR_INITIALIZER_LIST +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_ALLOCATOR +// 540 has std::align but it is not a conforming implementation +# define BOOST_NO_CXX11_STD_ALIGN #endif +// 520..610 have std::addressof, but it doesn't support functions +// +# define BOOST_NO_CXX11_ADDRESSOF + #ifdef _CPPLIB_VER # define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER #else @@ -146,12 +162,3 @@ #else # define BOOST_STDLIB "Dinkumware standard library version 1.x" #endif - - - - - - - - - diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/libcomo.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/libcomo.hpp index 29490f1b1..5aacfb2a7 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/libcomo.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/libcomo.hpp @@ -58,6 +58,9 @@ # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF // // Intrinsic type_traits support. diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/libcpp.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/libcpp.hpp index 3d574407e..88184ef90 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/libcpp.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/libcpp.hpp @@ -23,6 +23,14 @@ # define BOOST_NO_CXX11_HDR_TUPLE #endif +// BOOST_NO_CXX11_ALLOCATOR should imply no support for the C++11 +// allocator model. The C++11 allocator model requires a conforming +// std::allocator_traits which is only possible with C++11 template +// aliases since members rebind_alloc and rebind_traits require it. +#if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES) +# define BOOST_NO_CXX11_ALLOCATOR +#endif + // // These appear to be unusable/incomplete so far: // @@ -30,6 +38,7 @@ # define BOOST_NO_CXX11_HDR_FUTURE # define BOOST_NO_CXX11_HDR_TYPE_TRAITS # define BOOST_NO_CXX11_ATOMIC_SMART_PTR +# define BOOST_NO_CXX11_HDR_ATOMIC // libc++ uses a non-standard messages_base #define BOOST_NO_STD_MESSAGES diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/libstdcpp3.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/libstdcpp3.hpp index 976ab76ba..2fd6ea7d5 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/libstdcpp3.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/libstdcpp3.hpp @@ -107,7 +107,6 @@ // #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3) || !defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_NO_CXX11_HDR_ARRAY -# define BOOST_NO_CXX11_HDR_REGEX # define BOOST_NO_CXX11_HDR_TUPLE # define BOOST_NO_CXX11_HDR_UNORDERED_MAP # define BOOST_NO_CXX11_HDR_UNORDERED_SET @@ -146,21 +145,34 @@ // #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_NO_CXX11_HDR_TYPEINDEX +# define BOOST_NO_CXX11_ADDRESSOF #endif // C++0x features in GCC 4.7.0 and later // #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__) -// Note that although existed prior to 4.7, "stead_clock" is spelled "monotonic_clock" +// Note that although existed prior to 4.7, "steady_clock" is spelled "monotonic_clock" // so 4.7.0 is the first truely conforming one. # define BOOST_NO_CXX11_HDR_CHRONO # define BOOST_NO_CXX11_ALLOCATOR #endif +// C++0x features in GCC 4.7.0 and later +// +#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8) || !defined(__GXX_EXPERIMENTAL_CXX0X__) +// Note that although existed prior to gcc 4.8 it was largely unimplemented for many types: +# define BOOST_NO_CXX11_HDR_ATOMIC +#endif +#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9) || !defined(__GXX_EXPERIMENTAL_CXX0X__) +// Although is present and compilable against, the actual implementation is not functional +// even for the simplest patterns such as "\d" or "[0-9]". This is the case at least in gcc up to 4.8, inclusively. +# define BOOST_NO_CXX11_HDR_REGEX +#endif // C++0x headers not yet (fully!) implemented // # define BOOST_NO_CXX11_HDR_THREAD # define BOOST_NO_CXX11_HDR_TYPE_TRAITS # define BOOST_NO_CXX11_HDR_CODECVT # define BOOST_NO_CXX11_ATOMIC_SMART_PTR +# define BOOST_NO_CXX11_STD_ALIGN // --- end --- diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/modena.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/modena.hpp index b483b6e02..f2a83888c 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/modena.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/modena.hpp @@ -47,6 +47,9 @@ # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF #define BOOST_STDLIB "Modena C++ standard library" diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/msl.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/msl.hpp index 4f9a2da6e..b8f43a128 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/msl.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/msl.hpp @@ -71,6 +71,9 @@ # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__) diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/roguewave.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/roguewave.hpp index cb80f5708..2b4e8636c 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/roguewave.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/roguewave.hpp @@ -183,4 +183,7 @@ # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/sgi.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/sgi.hpp index ae9b6ad90..bda77c227 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/sgi.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/sgi.hpp @@ -141,6 +141,9 @@ # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF #define BOOST_STDLIB "SGI standard library" diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/stlport.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/stlport.hpp index bcc30b99e..fd5d3a5a6 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/stlport.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/stlport.hpp @@ -231,6 +231,9 @@ namespace boost { using std::min; using std::max; } # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT) diff --git a/src/thirdparty/boost_lib/boost/config/stdlib/vacpp.hpp b/src/thirdparty/boost_lib/boost/config/stdlib/vacpp.hpp index 9d1694655..a58ec1c5e 100644 --- a/src/thirdparty/boost_lib/boost/config/stdlib/vacpp.hpp +++ b/src/thirdparty/boost_lib/boost/config/stdlib/vacpp.hpp @@ -47,6 +47,9 @@ # define BOOST_NO_CXX11_ATOMIC_SMART_PTR # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_STD_ALIGN +# define BOOST_NO_CXX11_ADDRESSOF #define BOOST_STDLIB "Visual Age default standard library" diff --git a/src/thirdparty/boost_lib/boost/config/suffix.hpp b/src/thirdparty/boost_lib/boost/config/suffix.hpp index c55579ea6..a3fda5252 100644 --- a/src/thirdparty/boost_lib/boost/config/suffix.hpp +++ b/src/thirdparty/boost_lib/boost/config/suffix.hpp @@ -591,12 +591,33 @@ namespace std{ using ::type_info; } # define BOOST_NOINLINE __declspec(noinline) # elif defined(__GNUC__) && __GNUC__ > 3 // Clang also defines __GNUC__ (as 4) -# define BOOST_NOINLINE __attribute__ ((__noinline__)) +# if defined(__CUDACC__) + // nvcc doesn't always parse __noinline__, + // see: https://svn.boost.org/trac/boost/ticket/9392 +# define BOOST_NOINLINE __attribute__ ((noinline)) +# else +# define BOOST_NOINLINE __attribute__ ((__noinline__)) +# endif # else # define BOOST_NOINLINE # endif #endif +// BOOST_NORETURN ---------------------------------------------// +// Macro to use before a function declaration/definition to designate +// the function as not returning normally (i.e. with a return statement +// or by leaving the function scope, if the function return type is void). +#if !defined(BOOST_NORETURN) +# if defined(_MSC_VER) +# define BOOST_NORETURN __declspec(noreturn) +# elif defined(__GNUC__) +# define BOOST_NORETURN __attribute__ ((__noreturn__)) +# else +# define BOOST_NO_NORETURN +# define BOOST_NORETURN +# endif +#endif + // Branch prediction hints // These macros are intended to wrap conditional expressions that yield true or false // @@ -937,5 +958,14 @@ namespace std{ using ::type_info; } #define BOOST_HAS_VARIADIC_TMPL #endif +// +// Finish off with checks for macros that are depricated / no longer supported, +// if any of these are set then it's very likely that much of Boost will no +// longer work. So stop with a #error for now, but give the user a chance +// to continue at their own risk if they really want to: +// +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED) +# error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!" +#endif #endif diff --git a/src/thirdparty/boost_lib/boost/config/user.hpp b/src/thirdparty/boost_lib/boost/config/user.hpp index 5a4a9d477..d226a2d1f 100644 --- a/src/thirdparty/boost_lib/boost/config/user.hpp +++ b/src/thirdparty/boost_lib/boost/config/user.hpp @@ -85,8 +85,7 @@ // (this macro is used to turn on __declspec(dllimport) modifiers, so that // the compiler knows which symbols to look for in a dll rather than in a // static library). Note that there may be some libraries that can only -// be statically linked (Boost.Test for example) and others which may only -// be dynamically linked (Boost.Threads for example), in these cases this +// be linked in one way (statically or dynamically), in these cases this // macro has no effect. // #define BOOST_ALL_DYN_LINK @@ -97,9 +96,9 @@ // BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) // modifiers, so that the compiler knows which symbols to look for in a dll // rather than in a static library). -// Note that there may be some libraries that can only be statically linked -// (Boost.Test for example) and others which may only be dynamically linked -// (Boost.Threads for example), in these cases this macro is unsupported. +// Note that there may be some libraries that can only +// be linked in one way (statically or dynamically), +// in these cases this macro is unsupported. // #define BOOST_WHATEVER_DYN_LINK // BOOST_ALL_NO_LIB: Tells the config system not to automatically select diff --git a/src/thirdparty/boost_lib/boost/core/addressof.hpp b/src/thirdparty/boost_lib/boost/core/addressof.hpp new file mode 100644 index 000000000..a90fcc3e2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/addressof.hpp @@ -0,0 +1,162 @@ +// Copyright (C) 2002 Brad King (brad.king@kitware.com) +// Douglas Gregor (gregod@cs.rpi.edu) +// +// Copyright (C) 2002, 2008, 2013 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// For more information, see http://www.boost.org + +#ifndef BOOST_CORE_ADDRESSOF_HPP +#define BOOST_CORE_ADDRESSOF_HPP + +# include +# include +# include + +namespace boost +{ + +namespace detail +{ + +template struct addr_impl_ref +{ + T & v_; + + BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {} + BOOST_FORCEINLINE operator T& () const { return v_; } + +private: + addr_impl_ref & operator=(const addr_impl_ref &); +}; + +template struct addressof_impl +{ + static BOOST_FORCEINLINE T * f( T & v, long ) + { + return reinterpret_cast( + &const_cast(reinterpret_cast(v))); + } + + static BOOST_FORCEINLINE T * f( T * v, int ) + { + return v; + } +}; + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +#if defined( __clang__ ) && !defined( _LIBCPP_VERSION ) && !defined( BOOST_NO_CXX11_DECLTYPE ) + + typedef decltype(nullptr) addr_nullptr_t; + +#else + + typedef std::nullptr_t addr_nullptr_t; + +#endif + +template<> struct addressof_impl< addr_nullptr_t > +{ + typedef addr_nullptr_t T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +template<> struct addressof_impl< addr_nullptr_t const > +{ + typedef addr_nullptr_t const T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +template<> struct addressof_impl< addr_nullptr_t volatile > +{ + typedef addr_nullptr_t volatile T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +template<> struct addressof_impl< addr_nullptr_t const volatile > +{ + typedef addr_nullptr_t const volatile T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +#endif + +} // namespace detail + +template +BOOST_FORCEINLINE +T * addressof( T & v ) +{ +#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC ) + + return boost::detail::addressof_impl::f( v, 0 ); + +#else + + return boost::detail::addressof_impl::f( boost::detail::addr_impl_ref( v ), 0 ); + +#endif +} + +#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) ) + +namespace detail +{ + +template struct addressof_addp +{ + typedef T * type; +}; + +} // namespace detail + +template< class T, std::size_t N > +BOOST_FORCEINLINE +typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] ) +{ + return &t; +} + +#endif + +// Borland doesn't like casting an array reference to a char reference +// but these overloads work around the problem. +#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +template +BOOST_FORCEINLINE +T (*addressof(T (&t)[N]))[N] +{ + return reinterpret_cast(&t); +} + +template +BOOST_FORCEINLINE +const T (*addressof(const T (&t)[N]))[N] +{ + return reinterpret_cast(&t); +} +#endif + +} // namespace boost + +#endif // BOOST_CORE_ADDRESSOF_HPP diff --git a/src/thirdparty/boost_lib/boost/core/checked_delete.hpp b/src/thirdparty/boost_lib/boost/core/checked_delete.hpp new file mode 100644 index 000000000..b086e03e8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/checked_delete.hpp @@ -0,0 +1,69 @@ +#ifndef BOOST_CORE_CHECKED_DELETE_HPP +#define BOOST_CORE_CHECKED_DELETE_HPP + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/checked_delete.hpp +// +// Copyright (c) 2002, 2003 Peter Dimov +// Copyright (c) 2003 Daniel Frey +// Copyright (c) 2003 Howard Hinnant +// +// 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/core/doc/html/core/checked_delete.html for documentation. +// + +namespace boost +{ + +// verify that types are complete for increased safety + +template inline void checked_delete(T * x) +{ + // intentionally complex - simplification causes regressions + typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; + (void) sizeof(type_must_be_complete); + delete x; +} + +template inline void checked_array_delete(T * x) +{ + typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; + (void) sizeof(type_must_be_complete); + delete [] x; +} + +template struct checked_deleter +{ + typedef void result_type; + typedef T * argument_type; + + void operator()(T * x) const + { + // boost:: disables ADL + boost::checked_delete(x); + } +}; + +template struct checked_array_deleter +{ + typedef void result_type; + typedef T * argument_type; + + void operator()(T * x) const + { + boost::checked_array_delete(x); + } +}; + +} // namespace boost + +#endif // #ifndef BOOST_CORE_CHECKED_DELETE_HPP diff --git a/src/thirdparty/boost_lib/boost/core/demangle.hpp b/src/thirdparty/boost_lib/boost/core/demangle.hpp new file mode 100644 index 000000000..eebd0ce0f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/demangle.hpp @@ -0,0 +1,121 @@ +#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED +#define BOOST_CORE_DEMANGLE_HPP_INCLUDED + +// core::demangle +// +// Copyright 2014 Peter Dimov +// Copyright 2014 Andrey Semashev +// +// 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 +#include + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#if defined( __clang__ ) && defined( __has_include ) +# if __has_include() +# define BOOST_CORE_HAS_CXXABI_H +# endif +#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ ) +# define BOOST_CORE_HAS_CXXABI_H +#endif + +#if defined( BOOST_CORE_HAS_CXXABI_H ) +# include +# include +# include +#endif + +namespace boost +{ + +namespace core +{ + +inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT; +inline void demangle_free( char const * name ) BOOST_NOEXCEPT; + +class scoped_demangled_name +{ +private: + char const * m_p; + +public: + explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT : + m_p( demangle_alloc( name ) ) + { + } + + ~scoped_demangled_name() BOOST_NOEXCEPT + { + demangle_free( m_p ); + } + + char const * get() const BOOST_NOEXCEPT + { + return m_p; + } + + BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& )) + BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& )) +}; + + +#if defined( BOOST_CORE_HAS_CXXABI_H ) + +inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT +{ + int status = 0; + std::size_t size = 0; + return abi::__cxa_demangle( name, NULL, &size, &status ); +} + +inline void demangle_free( char const * name ) BOOST_NOEXCEPT +{ + std::free( const_cast< char* >( name ) ); +} + +inline std::string demangle( char const * name ) +{ + scoped_demangled_name demangled_name( name ); + char const * const p = demangled_name.get(); + if( p ) + { + return p; + } + else + { + return name; + } +} + +#else + +inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT +{ + return name; +} + +inline void demangle_free( char const * ) BOOST_NOEXCEPT +{ +} + +inline std::string demangle( char const * name ) +{ + return name; +} + +#endif + +} // namespace core + +} // namespace boost + +#undef BOOST_CORE_HAS_CXXABI_H + +#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/core/enable_if.hpp b/src/thirdparty/boost_lib/boost/core/enable_if.hpp new file mode 100644 index 000000000..a3302b18a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/enable_if.hpp @@ -0,0 +1,119 @@ +// Boost enable_if library + +// Copyright 2003 (c) The Trustees of Indiana University. + +// 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) + +// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) +// Jeremiah Willcock (jewillco at osl.iu.edu) +// Andrew Lumsdaine (lums at osl.iu.edu) + + +#ifndef BOOST_CORE_ENABLE_IF_HPP +#define BOOST_CORE_ENABLE_IF_HPP + +#include "boost/config.hpp" + +// Even the definition of enable_if causes problems on some compilers, +// so it's macroed out for all compilers that do not support SFINAE + +#ifndef BOOST_NO_SFINAE + +namespace boost +{ + + template + struct enable_if_c { + typedef T type; + }; + + template + struct enable_if_c {}; + + template + struct enable_if : public enable_if_c {}; + + template + struct lazy_enable_if_c { + typedef typename T::type type; + }; + + template + struct lazy_enable_if_c {}; + + template + struct lazy_enable_if : public lazy_enable_if_c {}; + + + template + struct disable_if_c { + typedef T type; + }; + + template + struct disable_if_c {}; + + template + struct disable_if : public disable_if_c {}; + + template + struct lazy_disable_if_c { + typedef typename T::type type; + }; + + template + struct lazy_disable_if_c {}; + + template + struct lazy_disable_if : public lazy_disable_if_c {}; + +} // namespace boost + +#else + +namespace boost { + + namespace detail { typedef void enable_if_default_T; } + + template + struct enable_if_does_not_work_on_this_compiler; + + template + struct enable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct disable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct enable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct disable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_enable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_disable_if : enable_if_does_not_work_on_this_compiler + { }; + +} // namespace boost + +#endif // BOOST_NO_SFINAE + +#endif diff --git a/src/thirdparty/boost_lib/boost/core/explicit_operator_bool.hpp b/src/thirdparty/boost_lib/boost/core/explicit_operator_bool.hpp new file mode 100644 index 000000000..a8936e2cd --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/explicit_operator_bool.hpp @@ -0,0 +1,154 @@ +/* + * Copyright Andrey Semashev 2007 - 2013. + * 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) + */ + +/*! + * \file explicit_operator_bool.hpp + * \author Andrey Semashev + * \date 08.03.2009 + * + * This header defines a compatibility macro that implements an unspecified + * \c bool operator idiom, which is superseded with explicit conversion operators in + * C++11. + */ + +#ifndef BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP +#define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + +/*! + * \brief The macro defines an explicit operator of conversion to \c bool + * + * The macro should be used inside the definition of a class that has to + * support the conversion. The class should also implement operator!, + * in terms of which the conversion operator will be implemented. + */ +#define BOOST_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE explicit operator bool () const\ + {\ + return !this->operator! ();\ + } + +/*! + * \brief The macro defines a noexcept explicit operator of conversion to \c bool + * + * The macro should be used inside the definition of a class that has to + * support the conversion. The class should also implement operator!, + * in terms of which the conversion operator will be implemented. + */ +#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\ + BOOST_FORCEINLINE explicit operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +/*! + * \brief The macro defines a constexpr explicit operator of conversion to \c bool + * + * The macro should be used inside the definition of a class that has to + * support the conversion. The class should also implement operator!, + * in terms of which the conversion operator will be implemented. + */ +#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + +#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG) +// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it +#define BOOST_NO_UNSPECIFIED_BOOL +#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG) + +#if !defined(BOOST_NO_UNSPECIFIED_BOOL) + +namespace boost { + +namespace detail { + +#if !defined(_MSC_VER) && !defined(__IBMCPP__) + + struct unspecified_bool + { + // NOTE TO THE USER: If you see this in error messages then you tried + // to apply an unsupported operator on the object that supports + // explicit conversion to bool. + struct OPERATORS_NOT_ALLOWED; + static void true_value(OPERATORS_NOT_ALLOWED*) {} + }; + typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*); + +#else + + // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't + struct unspecified_bool + { + // NOTE TO THE USER: If you see this in error messages then you tried + // to apply an unsupported operator on the object that supports + // explicit conversion to bool. + struct OPERATORS_NOT_ALLOWED; + void true_value(OPERATORS_NOT_ALLOWED*) {} + }; + typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*); + +#endif + +} // namespace detail + +} // namespace boost + +#define BOOST_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\ + {\ + return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ + } + +#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\ + BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\ + {\ + return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ + } + +#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\ + {\ + return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ + } + +#else // !defined(BOOST_NO_UNSPECIFIED_BOOL) + +#define BOOST_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE operator bool () const\ + {\ + return !this->operator! ();\ + } + +#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\ + BOOST_FORCEINLINE operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL) + +#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + +#endif // BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP diff --git a/src/thirdparty/boost_lib/boost/core/ignore_unused.hpp b/src/thirdparty/boost_lib/boost/core/ignore_unused.hpp new file mode 100644 index 000000000..22047c2e5 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/ignore_unused.hpp @@ -0,0 +1,70 @@ +// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland. +// +// 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) + +#ifndef BOOST_CORE_IGNORE_UNUSED_HPP +#define BOOST_CORE_IGNORE_UNUSED_HPP + +#include + +namespace boost { + +#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES + +template +inline void ignore_unused(Ts const& ...) +{} + +template +inline void ignore_unused() +{} + +#else + +template +inline void ignore_unused(T1 const&) +{} + +template +inline void ignore_unused(T1 const&, T2 const&) +{} + +template +inline void ignore_unused(T1 const&, T2 const&, T3 const&) +{} + +template +inline void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&) +{} + +template +inline void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&, T5 const&) +{} + +template +inline void ignore_unused() +{} + +template +inline void ignore_unused() +{} + +template +inline void ignore_unused() +{} + +template +inline void ignore_unused() +{} + +template +inline void ignore_unused() +{} + +#endif + +} // namespace boost + +#endif // BOOST_CORE_IGNORE_UNUSED_HPP diff --git a/src/thirdparty/boost_lib/boost/core/is_same.hpp b/src/thirdparty/boost_lib/boost/core/is_same.hpp new file mode 100644 index 000000000..f373c654d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/is_same.hpp @@ -0,0 +1,40 @@ +#ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED +#define BOOST_CORE_IS_SAME_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// is_same::value is true when T1 == T2 +// +// Copyright 2014 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt + +#include + +namespace boost +{ + +namespace core +{ + +template< class T1, class T2 > struct is_same +{ + BOOST_STATIC_CONSTANT( bool, value = false ); +}; + +template< class T > struct is_same< T, T > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +} // namespace core + +} // namespace boost + +#endif // #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/core/lightweight_test.hpp b/src/thirdparty/boost_lib/boost/core/lightweight_test.hpp new file mode 100644 index 000000000..f5943b3db --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/lightweight_test.hpp @@ -0,0 +1,171 @@ +#ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP +#define BOOST_CORE_LIGHTWEIGHT_TEST_HPP + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) +# pragma once +#endif + +// +// boost/core/lightweight_test.hpp - lightweight test library +// +// Copyright (c) 2002, 2009, 2014 Peter Dimov +// Copyright (2) Beman Dawes 2010, 2011 +// Copyright (3) Ion Gaztanaga 2013 +// +// 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 +#include +#include +#include + +// IDE's like Visual Studio perform better if output goes to std::cout or +// some other stream, so allow user to configure output stream: +#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM +# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr +#endif + +namespace boost +{ + +namespace detail +{ + +struct report_errors_reminder +{ + bool called_report_errors_function; + + report_errors_reminder() : called_report_errors_function(false) {} + + ~report_errors_reminder() + { + BOOST_ASSERT(called_report_errors_function); // verify report_errors() was called + } +}; + +inline report_errors_reminder& report_errors_remind() +{ + static report_errors_reminder r; + return r; +} + +inline int & test_errors() +{ + static int x = 0; + report_errors_remind(); + return x; +} + +inline void test_failed_impl(char const * expr, char const * file, int line, char const * function) +{ + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): test '" << expr << "' failed in function '" + << function << "'" << std::endl; + ++test_errors(); +} + +inline void error_impl(char const * msg, char const * file, int line, char const * function) +{ + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): " << msg << " in function '" + << function << "'" << std::endl; + ++test_errors(); +} + +inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function) +{ + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): Exception '" << excep << "' not thrown in function '" + << function << "'" << std::endl; + ++test_errors(); +} + +template inline void test_eq_impl( char const * expr1, char const * expr2, + char const * file, int line, char const * function, T const & t, U const & u ) +{ + if( t == u ) + { + report_errors_remind(); + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): test '" << expr1 << " == " << expr2 + << "' failed in function '" << function << "': " + << "'" << t << "' != '" << u << "'" << std::endl; + ++test_errors(); + } +} + +template inline void test_ne_impl( char const * expr1, char const * expr2, + char const * file, int line, char const * function, T const & t, U const & u ) +{ + if( t != u ) + { + report_errors_remind(); + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): test '" << expr1 << " != " << expr2 + << "' failed in function '" << function << "': " + << "'" << t << "' == '" << u << "'" << std::endl; + ++test_errors(); + } +} + +} // namespace detail + +inline int report_errors() +{ + detail::report_errors_remind().called_report_errors_function = true; + + int errors = detail::test_errors(); + + if( errors == 0 ) + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << "No errors detected." << std::endl; + return 0; + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl; + return 1; + } +} + +} // namespace boost + +#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)) + +#define BOOST_ERROR(msg) ( ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) ) + +#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) ) +#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) ) + +#ifndef BOOST_NO_EXCEPTIONS + #define BOOST_TEST_THROWS( EXPR, EXCEP ) \ + try { \ + EXPR; \ + ::boost::detail::throw_failed_impl \ + (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \ + } \ + catch(EXCEP const&) { \ + } \ + catch(...) { \ + ::boost::detail::throw_failed_impl \ + (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \ + } \ + // +#else + #define BOOST_TEST_THROWS( EXPR, EXCEP ) +#endif + +#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP diff --git a/src/thirdparty/boost_lib/boost/core/lightweight_test_trait.hpp b/src/thirdparty/boost_lib/boost/core/lightweight_test_trait.hpp new file mode 100644 index 000000000..0e2aab443 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/lightweight_test_trait.hpp @@ -0,0 +1,56 @@ +#ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP +#define BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) +# pragma once +#endif + +// boost/core/lightweight_test_trait.hpp +// +// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE +// +// Copyright 2014 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt + +#include +#include + +namespace boost +{ + +namespace detail +{ + +template< class T > inline void test_trait_impl( char const * trait, void (*)( T ), + bool expected, char const * file, int line, char const * function ) +{ + if( T::value == expected ) + { + report_errors_remind(); + } + else + { + BOOST_LIGHTWEIGHT_TEST_OSTREAM + << file << "(" << line << "): predicate '" << trait << "' [" + << boost::core::demangled_name( BOOST_CORE_TYPEID(T) ) << "]" + << " test failed in function '" << function + << "' (should have been " << ( expected? "true": "false" ) << ")" + << std::endl; + + ++test_errors(); + } +} + +} // namespace detail + +} // namespace boost + +#define BOOST_TEST_TRAIT_TRUE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, true, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) ) +#define BOOST_TEST_TRAIT_FALSE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, false, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) ) + +#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP diff --git a/src/thirdparty/boost_lib/boost/core/no_exceptions_support.hpp b/src/thirdparty/boost_lib/boost/core/no_exceptions_support.hpp new file mode 100644 index 000000000..a697f01a5 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/no_exceptions_support.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP +#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +//---------------------------------------------------------------------- +// (C) Copyright 2004 Pavel Vozenilek. +// 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) +// +// +// This file contains helper macros used when exception support may be +// disabled (as indicated by macro BOOST_NO_EXCEPTIONS). +// +// Before picking up these macros you may consider using RAII techniques +// to deal with exceptions - their syntax can be always the same with +// or without exception support enabled. +//---------------------------------------------------------------------- + +#include +#include + +#if !(defined BOOST_NO_EXCEPTIONS) +# define BOOST_TRY { try +# define BOOST_CATCH(x) catch(x) +# define BOOST_RETHROW throw; +# define BOOST_CATCH_END } +#else +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# define BOOST_TRY { if ("") +# define BOOST_CATCH(x) else if (!"") +# else +# define BOOST_TRY { if (true) +# define BOOST_CATCH(x) else if (false) +# endif +# define BOOST_RETHROW +# define BOOST_CATCH_END } +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/core/noncopyable.hpp b/src/thirdparty/boost_lib/boost/core/noncopyable.hpp new file mode 100644 index 000000000..6ae8c244d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/noncopyable.hpp @@ -0,0 +1,48 @@ +// Boost noncopyable.hpp header file --------------------------------------// + +// (C) Copyright Beman Dawes 1999-2003. 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/utility for documentation. + +#ifndef BOOST_CORE_NONCOPYABLE_HPP +#define BOOST_CORE_NONCOPYABLE_HPP + +#include + +namespace boost { + +// Private copy constructor and copy assignment ensure classes derived from +// class noncopyable cannot be copied. + +// Contributed by Dave Abrahams + +namespace noncopyable_ // protection from unintended ADL +{ + class noncopyable + { + protected: +#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) + BOOST_CONSTEXPR noncopyable() = default; + ~noncopyable() = default; +#else + noncopyable() {} + ~noncopyable() {} +#endif +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) + noncopyable( const noncopyable& ) = delete; + noncopyable& operator=( const noncopyable& ) = delete; +#else + private: // emphasize the following members are private + noncopyable( const noncopyable& ); + noncopyable& operator=( const noncopyable& ); +#endif + }; +} + +typedef noncopyable_::noncopyable noncopyable; + +} // namespace boost + +#endif // BOOST_CORE_NONCOPYABLE_HPP diff --git a/src/thirdparty/boost_lib/boost/core/null_deleter.hpp b/src/thirdparty/boost_lib/boost/core/null_deleter.hpp new file mode 100644 index 000000000..f0af59034 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/null_deleter.hpp @@ -0,0 +1,44 @@ +/* + * Copyright Andrey Semashev 2007 - 2014. + * 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) + */ +/*! + * \file null_deleter.hpp + * \author Andrey Semashev + * \date 22.04.2007 + * + * This header contains a \c null_deleter implementation. This is an empty + * function object that receives a pointer and does nothing with it. + * Such empty deletion strategy may be convenient, for example, when + * constructing shared_ptrs that point to some object that should not be + * deleted (i.e. a variable on the stack or some global singleton, like std::cout). + */ + +#ifndef BOOST_CORE_NULL_DELETER_HPP +#define BOOST_CORE_NULL_DELETER_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +//! A function object that does nothing and can be used as an empty deleter for \c shared_ptr +struct null_deleter +{ + //! Function object result type + typedef void result_type; + /*! + * Does nothing + */ + template< typename T > + void operator() (T*) const BOOST_NOEXCEPT {} +}; + +} // namespace boost + +#endif // BOOST_CORE_NULL_DELETER_HPP diff --git a/src/thirdparty/boost_lib/boost/core/ref.hpp b/src/thirdparty/boost_lib/boost/core/ref.hpp new file mode 100644 index 000000000..47dc85800 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/ref.hpp @@ -0,0 +1,301 @@ +#ifndef BOOST_CORE_REF_HPP +#define BOOST_CORE_REF_HPP + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include +#include +#include + +// +// ref.hpp - ref/cref, useful helper functions +// +// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// Copyright (C) 2001, 2002 Peter Dimov +// Copyright (C) 2002 David Abrahams +// +// Copyright (C) 2014 Glen Joseph Fernandes +// glenfe at live dot com +// Copyright (C) 2014 Agustin Berge +// +// 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/core/doc/html/core/ref.html for documentation. +// + +/** + @file +*/ + +/** + Boost namespace. +*/ +namespace boost +{ + +#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 ) + + struct ref_workaround_tag {}; + +#endif + +// reference_wrapper + +/** + @brief Contains a reference to an object of type `T`. + + `reference_wrapper` is primarily used to "feed" references to + function templates (algorithms) that take their parameter by + value. It provides an implicit conversion to `T&`, which + usually allows the function templates to work on references + unmodified. +*/ +template class reference_wrapper +{ +public: + /** + Type `T`. + */ + typedef T type; + + /** + Constructs a `reference_wrapper` object that stores a + reference to `t`. + + @remark Does not throw. + */ + BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {} + +#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 ) + + BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {} + +#endif + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + /** + @remark Construction from a temporary object is disabled. + */ + BOOST_DELETED_FUNCTION(reference_wrapper(T&& t)) +public: +#endif + + /** + @return The stored reference. + @remark Does not throw. + */ + BOOST_FORCEINLINE operator T& () const { return *t_; } + + /** + @return The stored reference. + @remark Does not throw. + */ + BOOST_FORCEINLINE T& get() const { return *t_; } + + /** + @return A pointer to the object referenced by the stored + reference. + @remark Does not throw. + */ + BOOST_FORCEINLINE T* get_pointer() const { return t_; } + +private: + + T* t_; +}; + +// ref + +/** + @cond +*/ +#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) +# define BOOST_REF_CONST +#else +# define BOOST_REF_CONST const +#endif +/** + @endcond +*/ + +/** + @return `reference_wrapper(t)` + @remark Does not throw. +*/ +template BOOST_FORCEINLINE reference_wrapper BOOST_REF_CONST ref( T & t ) +{ +#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 ) + + return reference_wrapper( t, ref_workaround_tag() ); + +#else + + return reference_wrapper( t ); + +#endif +} + +// cref + +/** + @return `reference_wrapper(t)` + @remark Does not throw. +*/ +template BOOST_FORCEINLINE reference_wrapper BOOST_REF_CONST cref( T const & t ) +{ + return reference_wrapper(t); +} + +#undef BOOST_REF_CONST + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +/** + @cond +*/ +#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) +# define BOOST_REF_DELETE +#else +# define BOOST_REF_DELETE = delete +#endif +/** + @endcond +*/ + +/** + @remark Construction from a temporary object is disabled. +*/ +template void ref(T const&&) BOOST_REF_DELETE; + +/** + @remark Construction from a temporary object is disabled. +*/ +template void cref(T const&&) BOOST_REF_DELETE; + +#undef BOOST_REF_DELETE + +#endif + +// is_reference_wrapper + +/** + @brief Determine if a type `T` is an instantiation of + `reference_wrapper`. + + The value static constant will be true if the type `T` is a + specialization of `reference_wrapper`. +*/ +template struct is_reference_wrapper +{ + BOOST_STATIC_CONSTANT( bool, value = false ); +}; + +/** + @cond +*/ +template struct is_reference_wrapper< reference_wrapper > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +#if !defined(BOOST_NO_CV_SPECIALIZATIONS) + +template struct is_reference_wrapper< reference_wrapper const > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +template struct is_reference_wrapper< reference_wrapper volatile > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +template struct is_reference_wrapper< reference_wrapper const volatile > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS) + +/** + @endcond +*/ + + +// unwrap_reference + +/** + @brief Find the type in a `reference_wrapper`. + + The `typedef` type is `T::type` if `T` is a + `reference_wrapper`, `T` otherwise. +*/ +template struct unwrap_reference +{ + typedef T type; +}; + +/** + @cond +*/ +template struct unwrap_reference< reference_wrapper > +{ + typedef T type; +}; + +#if !defined(BOOST_NO_CV_SPECIALIZATIONS) + +template struct unwrap_reference< reference_wrapper const > +{ + typedef T type; +}; + +template struct unwrap_reference< reference_wrapper volatile > +{ + typedef T type; +}; + +template struct unwrap_reference< reference_wrapper const volatile > +{ + typedef T type; +}; + +#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS) + +/** + @endcond +*/ + +// unwrap_ref + +/** + @return `unwrap_reference::type&(t)` + @remark Does not throw. +*/ +template BOOST_FORCEINLINE typename unwrap_reference::type& unwrap_ref( T & t ) +{ + return t; +} + +// get_pointer + +/** + @cond +*/ +template BOOST_FORCEINLINE T* get_pointer( reference_wrapper const & r ) +{ + return r.get_pointer(); +} +/** + @endcond +*/ + +} // namespace boost + +#endif // #ifndef BOOST_CORE_REF_HPP diff --git a/src/thirdparty/boost_lib/boost/core/scoped_enum.hpp b/src/thirdparty/boost_lib/boost/core/scoped_enum.hpp new file mode 100644 index 000000000..78c548bf8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/scoped_enum.hpp @@ -0,0 +1,192 @@ +// scoped_enum.hpp ---------------------------------------------------------// + +// Copyright Beman Dawes, 2009 +// Copyright (C) 2011-2012 Vicente J. Botet Escriba +// Copyright (C) 2012 Anthony Williams + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_CORE_SCOPED_ENUM_HPP +#define BOOST_CORE_SCOPED_ENUM_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost +{ + +#ifdef BOOST_NO_CXX11_SCOPED_ENUMS + + /** + * Meta-function to get the native enum type associated to an enum class or its emulation. + */ + template + struct native_type + { + /** + * The member typedef type names the native enum type associated to the scoped enum, + * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum. + */ + typedef typename EnumType::enum_type type; + }; + + /** + * Casts a scoped enum to its underlying type. + * + * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type. + * @param v A scoped enum. + * @returns The underlying type. + * @throws No-throws. + */ + template + UnderlyingType underlying_cast(EnumType v) + { + return v.get_underlying_value_(); + } + + /** + * Casts a scoped enum to its native enum type. + * + * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can. + * + * EnumType the scoped enum type + * + * @param v A scoped enum. + * @returns The native enum value. + * @throws No-throws. + */ + template + inline + typename EnumType::enum_type native_value(EnumType e) + { + return e.get_native_value_(); + } + +#else // BOOST_NO_CXX11_SCOPED_ENUMS + + template + struct native_type + { + typedef EnumType type; + }; + + template + UnderlyingType underlying_cast(EnumType v) + { + return static_cast(v); + } + + template + inline + EnumType native_value(EnumType e) + { + return e; + } + +#endif // BOOST_NO_CXX11_SCOPED_ENUMS +} + + +#ifdef BOOST_NO_CXX11_SCOPED_ENUMS + +#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS + +#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \ + explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); } + +#else + +#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR + +#endif + +/** + * Start a declaration of a scoped enum. + * + * @param EnumType The new scoped enum. + * @param UnderlyingType The underlying type. + */ +#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType) \ + struct EnumType { \ + typedef void is_boost_scoped_enum_tag; \ + typedef UnderlyingType underlying_type; \ + EnumType() BOOST_NOEXCEPT {} \ + explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {} \ + underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; } \ + BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \ + private: \ + underlying_type v_; \ + typedef EnumType self_type; \ + public: \ + enum enum_type + +#define BOOST_SCOPED_ENUM_DECLARE_END2() \ + enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \ + friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \ + friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \ + friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \ + friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \ + friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \ + friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \ + friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \ + friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \ + friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \ + friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \ + friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \ + friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \ + }; + +#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \ + ; \ + EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {} \ + BOOST_SCOPED_ENUM_DECLARE_END2() + +/** + * Starts a declaration of a scoped enum with the default int underlying type. + * + * @param EnumType The new scoped enum. + */ +#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \ + BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int) + +/** + * Name of the native enum type. + * + * @param EnumType The new scoped enum. + */ +#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type +/** + * Forward declares an scoped enum. + * + * @param EnumType The scoped enum. + */ +#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType + +#else // BOOST_NO_CXX11_SCOPED_ENUMS + +#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType : UnderlyingType +#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType +#define BOOST_SCOPED_ENUM_DECLARE_END2() +#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ; + +#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType +#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType + +#endif // BOOST_NO_CXX11_SCOPED_ENUMS + +// Deprecated macros +#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name) +#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2() +#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name) + +#endif // BOOST_CORE_SCOPED_ENUM_HPP diff --git a/src/thirdparty/boost_lib/boost/core/swap.hpp b/src/thirdparty/boost_lib/boost/core/swap.hpp new file mode 100644 index 000000000..baa1be970 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/swap.hpp @@ -0,0 +1,60 @@ +// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker +// +// 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) +// For more information, see http://www.boost.org + + +#ifndef BOOST_CORE_SWAP_HPP +#define BOOST_CORE_SWAP_HPP + +// Note: the implementation of this utility contains various workarounds: +// - swap_impl is put outside the boost namespace, to avoid infinite +// recursion (causing stack overflow) when swapping objects of a primitive +// type. +// - swap_impl has a using-directive, rather than a using-declaration, +// because some compilers (including MSVC 7.1, Borland 5.9.3, and +// Intel 8.1) don't do argument-dependent lookup when it has a +// using-declaration instead. +// - boost::swap has two template arguments, instead of one, to +// avoid ambiguity when swapping objects of a Boost type that does +// not have its own boost::swap overload. + +#include //for std::swap (C++11) +#include //for std::swap (C++98) +#include //for std::size_t +#include + +namespace boost_swap_impl +{ + template + BOOST_GPU_ENABLED + void swap_impl(T& left, T& right) + { + using namespace std;//use std::swap if argument dependent lookup fails + swap(left,right); + } + + template + BOOST_GPU_ENABLED + void swap_impl(T (& left)[N], T (& right)[N]) + { + for (std::size_t i = 0; i < N; ++i) + { + ::boost_swap_impl::swap_impl(left[i], right[i]); + } + } +} + +namespace boost +{ + template + BOOST_GPU_ENABLED + void swap(T1& left, T2& right) + { + ::boost_swap_impl::swap_impl(left, right); + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/core/typeinfo.hpp b/src/thirdparty/boost_lib/boost/core/typeinfo.hpp new file mode 100644 index 000000000..e67b4a319 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/typeinfo.hpp @@ -0,0 +1,151 @@ +#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED +#define BOOST_CORE_TYPEINFO_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// core::typeinfo, BOOST_CORE_TYPEID +// +// Copyright 2007, 2014 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + +#if defined( BOOST_NO_TYPEID ) + +#include +#include + +namespace boost +{ + +namespace core +{ + +class typeinfo +{ +private: + + typeinfo( typeinfo const& ); + typeinfo& operator=( typeinfo const& ); + + char const * name_; + +public: + + explicit typeinfo( char const * name ): name_( name ) + { + } + + bool operator==( typeinfo const& rhs ) const + { + return this == &rhs; + } + + bool operator!=( typeinfo const& rhs ) const + { + return this != &rhs; + } + + bool before( typeinfo const& rhs ) const + { + return std::less< typeinfo const* >()( this, &rhs ); + } + + char const* name() const + { + return name_; + } +}; + +inline char const * demangled_name( core::typeinfo const & ti ) +{ + return ti.name(); +} + +} // namespace core + +namespace detail +{ + +template struct core_typeid_ +{ + static boost::core::typeinfo ti_; + + static char const * name() + { + return BOOST_CURRENT_FUNCTION; + } +}; + +#if defined(__SUNPRO_CC) +// see #4199, the Sun Studio compiler gets confused about static initialization +// constructor arguments. But an assignment works just fine. +template boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name(); +#else +template boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name()); +#endif + +template struct core_typeid_< T & >: core_typeid_< T > +{ +}; + +template struct core_typeid_< T const >: core_typeid_< T > +{ +}; + +template struct core_typeid_< T volatile >: core_typeid_< T > +{ +}; + +template struct core_typeid_< T const volatile >: core_typeid_< T > +{ +}; + +} // namespace detail + +} // namespace boost + +#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_::ti_) + +#else + +#include +#include + +namespace boost +{ + +namespace core +{ + +#if defined( BOOST_NO_STD_TYPEINFO ) + +typedef ::type_info typeinfo; + +#else + +typedef std::type_info typeinfo; + +#endif + +inline std::string demangled_name( core::typeinfo const & ti ) +{ + return core::demangle( ti.name() ); +} + +} // namespace core + +} // namespace boost + +#define BOOST_CORE_TYPEID(T) typeid(T) + +#endif + +#endif // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/core/underlying_type.hpp b/src/thirdparty/boost_lib/boost/core/underlying_type.hpp new file mode 100644 index 000000000..c79a0a6e5 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/core/underlying_type.hpp @@ -0,0 +1,79 @@ +// underlying_type.hpp ---------------------------------------------------------// + +// Copyright Beman Dawes, 2009 +// Copyright (C) 2011-2012 Vicente J. Botet Escriba +// Copyright (C) 2012 Anthony Williams +// Copyright (C) 2014 Andrey Semashev + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_CORE_UNDERLYING_TYPE_HPP +#define BOOST_CORE_UNDERLYING_TYPE_HPP + +#include + +// GCC 4.7 and later seem to provide std::underlying_type +#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) || (defined(BOOST_GCC) && BOOST_GCC >= 40700 && defined(__GXX_EXPERIMENTAL_CXX0X__)) +#include +#define BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +namespace detail { + +template< typename EnumType, typename Void = void > +struct underlying_type_impl; + +#if defined(BOOST_NO_CXX11_SCOPED_ENUMS) + +// Support for boost/core/scoped_enum.hpp +template< typename EnumType > +struct underlying_type_impl< EnumType, typename EnumType::is_boost_scoped_enum_tag > +{ + /** + * The member typedef type names the underlying type of EnumType. It is EnumType::underlying_type when the EnumType is an emulated scoped enum, + */ + typedef typename EnumType::underlying_type type; +}; + +#endif + +#if defined(BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE) + +template< typename EnumType, typename Void > +struct underlying_type_impl +{ + typedef typename std::underlying_type< EnumType >::type type; +}; + +#endif + +} // namespace detail + +#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE) +#define BOOST_NO_UNDERLYING_TYPE +#endif + +/** + * Meta-function to get the underlying type of a scoped enum. + * + * Requires EnumType must be an enum type or the emulation of a scoped enum. + * If BOOST_NO_UNDERLYING_TYPE is defined, the implementation will not be able + * to deduce the underlying type of enums. The used is expected to specialize + * this trait. + */ +template< typename EnumType > +struct underlying_type : + public detail::underlying_type_impl< EnumType > +{ +}; + +} // namespace boost + +#endif // BOOST_CORE_UNDERLYING_TYPE_HPP diff --git a/src/thirdparty/boost_lib/boost/current_function.hpp b/src/thirdparty/boost_lib/boost/current_function.hpp index cb36e35c3..5c113f809 100644 --- a/src/thirdparty/boost_lib/boost/current_function.hpp +++ b/src/thirdparty/boost_lib/boost/current_function.hpp @@ -12,11 +12,11 @@ // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt // -// http://www.boost.org/libs/utility/current_function.html +// http://www.boost.org/libs/assert/current_function.html // namespace boost @@ -52,6 +52,10 @@ inline void current_function_helper() # define BOOST_CURRENT_FUNCTION __func__ +#elif defined(__cplusplus) && (__cplusplus >= 201103) + +# define BOOST_CURRENT_FUNCTION __func__ + #else # define BOOST_CURRENT_FUNCTION "(unknown)" @@ -65,4 +69,3 @@ inline void current_function_helper() } // namespace boost #endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED - diff --git a/src/thirdparty/boost_lib/boost/date_time.hpp b/src/thirdparty/boost_lib/boost/date_time.hpp index 07715262c..51628cd32 100644 --- a/src/thirdparty/boost_lib/boost/date_time.hpp +++ b/src/thirdparty/boost_lib/boost/date_time.hpp @@ -6,7 +6,7 @@ * Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) * Author: Jeff Garland - * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $ + * $Date$ */ // See www.boost.org/libs/date_time for documentation. diff --git a/src/thirdparty/boost_lib/boost/detail/allocator_utilities.hpp b/src/thirdparty/boost_lib/boost/detail/allocator_utilities.hpp index 5d6ef48b0..ed3de8466 100644 --- a/src/thirdparty/boost_lib/boost/detail/allocator_utilities.hpp +++ b/src/thirdparty/boost_lib/boost/detail/allocator_utilities.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2009 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -11,7 +11,6 @@ #include /* keep it first to prevent nasty warns in MSVC */ #include -#include #include #include #include @@ -116,29 +115,6 @@ struct partial_std_allocator_rebind_to /* rebind operation in all other cases */ -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) -/* Workaround for a problem in MSVC with dependent template typedefs - * when doing rebinding of allocators. - * Modeled after (thanks, Aleksey!) - */ - -template -struct rebinder -{ - template struct fake_allocator:Allocator{}; - template<> struct fake_allocator - { - template struct rebind{}; - }; - - template - struct result: - fake_allocator::value>:: - template rebind - { - }; -}; -#else template struct rebinder { @@ -149,7 +125,6 @@ struct rebinder rebind::other other; }; }; -#endif template struct compliant_allocator_rebind_to diff --git a/src/thirdparty/boost_lib/boost/detail/basic_pointerbuf.hpp b/src/thirdparty/boost_lib/boost/detail/basic_pointerbuf.hpp new file mode 100644 index 000000000..1d8cf373b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/detail/basic_pointerbuf.hpp @@ -0,0 +1,139 @@ +//----------------------------------------------------------------------------- +// boost detail/templated_streams.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2013 John Maddock, Antony Polukhin +// +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_DETAIL_BASIC_POINTERBUF_HPP +#define BOOST_DETAIL_BASIC_POINTERBUF_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#include "boost/config.hpp" +#include + +namespace boost { namespace detail { + +// +// class basic_pointerbuf: +// acts as a stream buffer which wraps around a pair of pointers: +// +template +class basic_pointerbuf : public BufferT { +protected: + typedef BufferT base_type; + typedef basic_pointerbuf this_type; + typedef typename base_type::int_type int_type; + typedef typename base_type::char_type char_type; + typedef typename base_type::pos_type pos_type; + typedef ::std::streamsize streamsize; + typedef typename base_type::off_type off_type; + +public: + basic_pointerbuf() : base_type() { setbuf(0, 0); } + const charT* getnext() { return this->gptr(); } + +#ifndef BOOST_NO_USING_TEMPLATE + using base_type::pptr; + using base_type::pbase; +#else + charT* pptr() const { return base_type::pptr(); } + charT* pbase() const { return base_type::pbase(); } +#endif + +protected: + // VC mistakenly assumes that `setbuf` and other functions are not referenced. + // Marking those functions with `inline` suppresses the warnings. + // There must be no harm from marking virtual functions as inline: inline virtual + // call can be inlined ONLY when the compiler knows the "exact class". + inline base_type* setbuf(char_type* s, streamsize n); + inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which); + inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which); + +private: + basic_pointerbuf& operator=(const basic_pointerbuf&); + basic_pointerbuf(const basic_pointerbuf&); +}; + +template +BufferT* +basic_pointerbuf::setbuf(char_type* s, streamsize n) +{ + this->setg(s, s, s + n); + return this; +} + +template +typename basic_pointerbuf::pos_type +basic_pointerbuf::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) +{ + typedef typename boost::int_t::least cast_type; + + if(which & ::std::ios_base::out) + return pos_type(off_type(-1)); + std::ptrdiff_t size = this->egptr() - this->eback(); + std::ptrdiff_t pos = this->gptr() - this->eback(); + charT* g = this->eback(); + switch(static_cast(way)) + { + case ::std::ios_base::beg: + if((off < 0) || (off > size)) + return pos_type(off_type(-1)); + else + this->setg(g, g + off, g + size); + break; + case ::std::ios_base::end: + if((off < 0) || (off > size)) + return pos_type(off_type(-1)); + else + this->setg(g, g + size - off, g + size); + break; + case ::std::ios_base::cur: + { + std::ptrdiff_t newpos = static_cast(pos + off); + if((newpos < 0) || (newpos > size)) + return pos_type(off_type(-1)); + else + this->setg(g, g + newpos, g + size); + break; + } + default: ; + } +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4244) +#endif + return static_cast(this->gptr() - this->eback()); +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif +} + +template +typename basic_pointerbuf::pos_type +basic_pointerbuf::seekpos(pos_type sp, ::std::ios_base::openmode which) +{ + if(which & ::std::ios_base::out) + return pos_type(off_type(-1)); + off_type size = static_cast(this->egptr() - this->eback()); + charT* g = this->eback(); + if(off_type(sp) <= size) + { + this->setg(g, g + off_type(sp), g + size); + } + return pos_type(off_type(-1)); +} + +}} // namespace boost::detail + +#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP + diff --git a/src/thirdparty/boost_lib/boost/detail/catch_exceptions.hpp b/src/thirdparty/boost_lib/boost/detail/catch_exceptions.hpp index b1a3c76b2..823ebd1e2 100644 --- a/src/thirdparty/boost_lib/boost/detail/catch_exceptions.hpp +++ b/src/thirdparty/boost_lib/boost/detail/catch_exceptions.hpp @@ -24,11 +24,7 @@ #include // for exception, bad_exception #include // for std exception hierarchy #include // for exit codes -# if __GNUC__ != 2 || __GNUC_MINOR__ > 96 -# include // for ostream -# else -# include // workaround GNU missing ostream header -# endif +#include // for ostream # if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0551) # define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT diff --git a/src/thirdparty/boost_lib/boost/detail/compressed_pair.hpp b/src/thirdparty/boost_lib/boost/detail/compressed_pair.hpp index 3f326456c..5dc21e23e 100644 --- a/src/thirdparty/boost_lib/boost/detail/compressed_pair.hpp +++ b/src/thirdparty/boost_lib/boost/detail/compressed_pair.hpp @@ -6,7 +6,7 @@ // See http://www.boost.org/libs/utility for most recent version including documentation. // compressed_pair: pair that "compresses" empty members -// (see libs/utility/compressed_pair.htm) +// (see libs/utility/doc/html/compressed_pair.html) // // JM changes 25 Jan 2004: // For the case where T1 == T2 and both are empty, then first() and second() diff --git a/src/thirdparty/boost_lib/boost/detail/container_fwd.hpp b/src/thirdparty/boost_lib/boost/detail/container_fwd.hpp index ef1749806..04ce97273 100644 --- a/src/thirdparty/boost_lib/boost/detail/container_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/detail/container_fwd.hpp @@ -8,7 +8,7 @@ #if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP) #define BOOST_DETAIL_CONTAINER_FWD_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) && \ +#if defined(_MSC_VER) && \ !defined(BOOST_DETAIL_TEST_CONFIG_ONLY) # pragma once #endif @@ -119,12 +119,7 @@ namespace std template class allocator; template class basic_string; -#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - - template struct string_char_traits; -#else template struct char_traits; -#endif #if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT) template struct complex; diff --git a/src/thirdparty/boost_lib/boost/detail/dynamic_bitset.hpp b/src/thirdparty/boost_lib/boost/detail/dynamic_bitset.hpp index 281aa55cd..e0f675d5e 100644 --- a/src/thirdparty/boost_lib/boost/detail/dynamic_bitset.hpp +++ b/src/thirdparty/boost_lib/boost/detail/dynamic_bitset.hpp @@ -3,6 +3,9 @@ // Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek // Copyright (c) 2003-2006, 2008 Gennaro Prota // +// Copyright (c) 2014 Glen Joseph Fernandes +// glenfe at live dot com +// // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) @@ -12,6 +15,7 @@ #ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP #define BOOST_DETAIL_DYNAMIC_BITSET_HPP +#include #include #include "boost/config.hpp" #include "boost/detail/workaround.hpp" @@ -155,17 +159,25 @@ namespace boost { // meaningful info. // template - typename T::size_type vector_max_size_workaround(const T & v) { + inline typename T::size_type vector_max_size_workaround(const T & v) + BOOST_NOEXCEPT + { + typedef typename T::allocator_type allocator_type; + + const allocator_type& alloc = v.get_allocator(); - typedef typename T::allocator_type allocator_type; +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef std::allocator_traits allocator_traits; + + const typename allocator_traits::size_type alloc_max = + allocator_traits::max_size(alloc); +#else + const typename allocator_type::size_type alloc_max = alloc.max_size(); +#endif - const typename allocator_type::size_type alloc_max = - v.get_allocator().max_size(); - const typename T::size_type container_max = v.max_size(); + const typename T::size_type container_max = v.max_size(); - return alloc_max < container_max? - alloc_max : - container_max; + return alloc_max < container_max ? alloc_max : container_max; } // for static_asserts diff --git a/src/thirdparty/boost_lib/boost/detail/endian.hpp b/src/thirdparty/boost_lib/boost/detail/endian.hpp index 3e37db93d..f576c26b8 100644 --- a/src/thirdparty/boost_lib/boost/detail/endian.hpp +++ b/src/thirdparty/boost_lib/boost/detail/endian.hpp @@ -1,4 +1,4 @@ -// Copyright 2013 Redshift Software Inc +// Copyright 2013 Rene Rivera // Distributed under the Boost Software License, Version 1.0. (See accompany- // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/src/thirdparty/boost_lib/boost/detail/fenv.hpp b/src/thirdparty/boost_lib/boost/detail/fenv.hpp index f04870641..b268f5c1c 100644 --- a/src/thirdparty/boost_lib/boost/detail/fenv.hpp +++ b/src/thirdparty/boost_lib/boost/detail/fenv.hpp @@ -14,7 +14,7 @@ #if !defined(BOOST_DETAIL_FENV_HPP) #define BOOST_DETAIL_FENV_HPP -/* If we're using clang + glibc, we have to get hacky. +/* If we're using clang + glibc, we have to get hacky. * See http://llvm.org/bugs/show_bug.cgi?id=6907 */ #if defined(__clang__) && (__clang_major__ < 3) && \ defined(__GNU_LIBRARY__) && /* up to version 5 */ \ @@ -61,14 +61,41 @@ using ::feholdexcept; } } +#elif defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 + + // MinGW (32-bit) has a bug in mingw32/bits/c++config.h, it does not define _GLIBCXX_HAVE_FENV_H, + // which prevents the C fenv.h header contents to be included in the C++ wrapper header fenv.h. This is at least + // the case with gcc 4.8.1 packages tested so far, up to 4.8.1-4. Note that there is no issue with + // MinGW-w64. + // To work around the bug we avoid including the C++ wrapper header and include the C header directly + // and import all relevant symbols into std:: ourselves. + + #include <../include/fenv.h> + + namespace std { + using ::fenv_t; + using ::fexcept_t; + using ::fegetexceptflag; + using ::fesetexceptflag; + using ::feclearexcept; + using ::feraiseexcept; + using ::fetestexcept; + using ::fegetround; + using ::fesetround; + using ::fegetenv; + using ::fesetenv; + using ::feupdateenv; + using ::feholdexcept; + } + #else /* if we're not using GNU's C stdlib, fenv.h should work with clang */ + #if defined(__SUNPRO_CC) /* lol suncc */ #include #endif - + #include #endif #endif /* BOOST_DETAIL_FENV_HPP */ - diff --git a/src/thirdparty/boost_lib/boost/detail/identifier.hpp b/src/thirdparty/boost_lib/boost/detail/identifier.hpp index 688a664f7..063d23801 100644 --- a/src/thirdparty/boost_lib/boost/detail/identifier.hpp +++ b/src/thirdparty/boost_lib/boost/detail/identifier.hpp @@ -57,9 +57,7 @@ namespace boost identifier() {} explicit identifier( value_type v ) : m_value(v) {} - #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // 1300 == VC++ 7.0 bug workaround private: - #endif T m_value; }; diff --git a/src/thirdparty/boost_lib/boost/detail/indirect_traits.hpp b/src/thirdparty/boost_lib/boost/detail/indirect_traits.hpp index f9c0cd6a0..7c8f76b09 100644 --- a/src/thirdparty/boost_lib/boost/detail/indirect_traits.hpp +++ b/src/thirdparty/boost_lib/boost/detail/indirect_traits.hpp @@ -26,15 +26,11 @@ # include # include -# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# include -# endif namespace boost { namespace detail { namespace indirect_traits { -# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_reference_to_const : mpl::false_ { @@ -199,284 +195,6 @@ struct is_pointer_to_class BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T)) }; -# else - -using namespace boost::detail::is_function_ref_tester_; - -typedef char (&inner_yes_type)[3]; -typedef char (&inner_no_type)[2]; -typedef char (&outer_no_type)[1]; - -template -struct is_const_help -{ - typedef typename mpl::if_< - is_const - , inner_yes_type - , inner_no_type - >::type type; -}; - -template -struct is_volatile_help -{ - typedef typename mpl::if_< - is_volatile - , inner_yes_type - , inner_no_type - >::type type; -}; - -template -struct is_pointer_help -{ - typedef typename mpl::if_< - is_pointer - , inner_yes_type - , inner_no_type - >::type type; -}; - -template -struct is_class_help -{ - typedef typename mpl::if_< - is_class - , inner_yes_type - , inner_no_type - >::type type; -}; - -template -struct is_reference_to_function_aux -{ - static T t; - BOOST_STATIC_CONSTANT( - bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type)); - typedef mpl::bool_ type; - }; - -template -struct is_reference_to_function - : mpl::if_, is_reference_to_function_aux, mpl::bool_ >::type -{ -}; - -template -struct is_pointer_to_function_aux -{ - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type)); - typedef mpl::bool_ type; -}; - -template -struct is_pointer_to_function - : mpl::if_, is_pointer_to_function_aux, mpl::bool_ >::type -{ - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T)) -}; - -struct false_helper1 -{ - template - struct apply : mpl::false_ - { - }; -}; - -template -typename is_const_help::type reference_to_const_helper(V&); -outer_no_type -reference_to_const_helper(...); - -struct true_helper1 -{ - template - struct apply - { - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type)); - typedef mpl::bool_ type; - }; -}; - -template -struct is_reference_to_const_helper1 : true_helper1 -{ -}; - -template <> -struct is_reference_to_const_helper1 : false_helper1 -{ -}; - - -template -struct is_reference_to_const - : is_reference_to_const_helper1::value>::template apply -{ -}; - - -template -struct is_reference_to_non_const_helper1 -{ - template - struct apply - { - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type)); - - typedef mpl::bool_ type; - }; -}; - -template <> -struct is_reference_to_non_const_helper1 : false_helper1 -{ -}; - - -template -struct is_reference_to_non_const - : is_reference_to_non_const_helper1::value>::template apply -{ - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T)) -}; - - -template -typename is_volatile_help::type reference_to_volatile_helper(V&); -outer_no_type -reference_to_volatile_helper(...); - -template -struct is_reference_to_volatile_helper1 -{ - template - struct apply - { - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type)); - typedef mpl::bool_ type; - }; -}; - -template <> -struct is_reference_to_volatile_helper1 : false_helper1 -{ -}; - - -template -struct is_reference_to_volatile - : is_reference_to_volatile_helper1::value>::template apply -{ -}; - -template -typename is_pointer_help::type reference_to_pointer_helper(V&); -outer_no_type reference_to_pointer_helper(...); - -template -struct reference_to_pointer_impl -{ - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type)) - ); - - typedef mpl::bool_ type; -}; - -template -struct is_reference_to_pointer - : mpl::eval_if, reference_to_pointer_impl, mpl::false_>::type -{ - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T)) -}; - -template -struct is_reference_to_function_pointer - : mpl::eval_if, is_pointer_to_function_aux, mpl::false_>::type -{ - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T)) -}; - - -template -struct is_member_function_pointer_help - : mpl::if_, inner_yes_type, inner_no_type> -{}; - -template -typename is_member_function_pointer_help::type member_function_pointer_helper(V&); -outer_no_type member_function_pointer_helper(...); - -template -struct is_pointer_to_member_function_aux -{ - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type)); - typedef mpl::bool_ type; -}; - -template -struct is_reference_to_member_function_pointer - : mpl::if_< - is_reference - , is_pointer_to_member_function_aux - , mpl::bool_ - >::type -{ - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T)) -}; - -template -typename is_class_help::type reference_to_class_helper(V const volatile&); -outer_no_type reference_to_class_helper(...); - -template -struct is_reference_to_class -{ - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = (is_reference::value - & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type))) - ); - typedef mpl::bool_ type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T)) -}; - -template -typename is_class_help::type pointer_to_class_helper(V const volatile*); -outer_no_type pointer_to_class_helper(...); - -template -struct is_pointer_to_class -{ - static T t; - BOOST_STATIC_CONSTANT( - bool, value - = (is_pointer::value - && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type)) - ); - typedef mpl::bool_ type; -}; -# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } diff --git a/src/thirdparty/boost_lib/boost/detail/is_function_ref_tester.hpp b/src/thirdparty/boost_lib/boost/detail/is_function_ref_tester.hpp deleted file mode 100644 index 8e7d1d77f..000000000 --- a/src/thirdparty/boost_lib/boost/detail/is_function_ref_tester.hpp +++ /dev/null @@ -1,136 +0,0 @@ - -// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, -// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. -// 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) - -#if !defined(BOOST_PP_IS_ITERATING) - -///// header body - -#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED -#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED - -#include "boost/type_traits/detail/yes_no_type.hpp" -#include "boost/type_traits/config.hpp" - -#if defined(BOOST_TT_PREPROCESSING_MODE) -# include "boost/preprocessor/iterate.hpp" -# include "boost/preprocessor/enum_params.hpp" -# include "boost/preprocessor/comma_if.hpp" -#endif - -namespace boost { -namespace detail { -namespace is_function_ref_tester_ { - -template -boost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...); - -#if !defined(BOOST_TT_PREPROCESSING_MODE) -// preprocessor-generated part, don't edit by hand! - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int); - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int); - -#else - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (0, 25, "boost/detail/is_function_ref_tester.hpp")) -#include BOOST_PP_ITERATE() - -#endif // BOOST_TT_PREPROCESSING_MODE - -} // namespace detail -} // namespace python -} // namespace boost - -#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED - -///// iteration - -#else -#define i BOOST_PP_FRAME_ITERATION(1) - -template -boost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int); - -#undef i -#endif // BOOST_PP_IS_ITERATING - diff --git a/src/thirdparty/boost_lib/boost/detail/is_incrementable.hpp b/src/thirdparty/boost_lib/boost/detail/is_incrementable.hpp index e7ef9dc62..6b36378fa 100644 --- a/src/thirdparty/boost_lib/boost/detail/is_incrementable.hpp +++ b/src/thirdparty/boost_lib/boost/detail/is_incrementable.hpp @@ -55,8 +55,7 @@ namespace is_incrementable_ # endif -# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ - || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) # define BOOST_comma(a,b) (a) # else // In case an operator++ is found that returns void, we'll use ++x,0 diff --git a/src/thirdparty/boost_lib/boost/detail/is_xxx.hpp b/src/thirdparty/boost_lib/boost/detail/is_xxx.hpp index cb64fb32b..3f9a1265e 100644 --- a/src/thirdparty/boost_lib/boost/detail/is_xxx.hpp +++ b/src/thirdparty/boost_lib/boost/detail/is_xxx.hpp @@ -8,39 +8,6 @@ # include # include -# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -# include -# include - -# define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs) \ -template \ -struct is_##name \ -{ \ - typedef char yes; \ - typedef char (&no)[2]; \ - \ - static typename add_reference::type dummy; \ - \ - struct helpers \ - { \ - template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class U) > \ - static yes test( \ - qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, U) >&, int \ - ); \ - \ - template \ - static no test(U&, ...); \ - }; \ - \ - BOOST_STATIC_CONSTANT( \ - bool, value \ - = !is_reference::value \ - & (sizeof(helpers::test(dummy, 0)) == sizeof(yes))); \ - \ - typedef mpl::bool_ type; \ -}; - -# else # define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs) \ template \ @@ -56,6 +23,5 @@ struct is_##name< \ { \ }; -# endif #endif // BOOST_DETAIL_IS_XXX_DWA20051011_HPP diff --git a/src/thirdparty/boost_lib/boost/detail/iterator.hpp b/src/thirdparty/boost_lib/boost/detail/iterator.hpp index 5bb9c6269..c2e8f1e2a 100644 --- a/src/thirdparty/boost_lib/boost/detail/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/detail/iterator.hpp @@ -3,492 +3,24 @@ // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -// Boost versions of -// -// std::iterator_traits<>::iterator_category -// std::iterator_traits<>::difference_type -// std::distance() -// -// ...for all compilers and iterators -// -// Additionally, if X is a pointer -// std::iterator_traits::pointer - -// Otherwise, if partial specialization is supported or X is not a pointer -// std::iterator_traits::value_type -// std::iterator_traits::pointer -// std::iterator_traits::reference -// -// See http://www.boost.org for most recent version including documentation. - -// Revision History -// 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams) -// 03 Mar 2001 - Put all implementation into namespace -// boost::detail::iterator_traits_. Some progress made on fixes -// for Intel compiler. (David Abrahams) -// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few -// places. (Jeremy Siek) -// 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and -// no_type from type_traits.hpp; stopped trying to remove_cv -// before detecting is_pointer, in honor of the new type_traits -// semantics. (David Abrahams) -// 13 Feb 2001 - Make it work with nearly all standard-conforming iterators -// under raw VC6. The one category remaining which will fail is -// that of iterators derived from std::iterator but not -// boost::iterator and which redefine difference_type. -// 11 Feb 2001 - Clean away code which can never be used (David Abrahams) -// 09 Feb 2001 - Always have a definition for each traits member, even if it -// can't be properly deduced. These will be incomplete types in -// some cases (undefined), but it helps suppress MSVC errors -// elsewhere (David Abrahams) -// 07 Feb 2001 - Support for more of the traits members where possible, making -// this useful as a replacement for std::iterator_traits when -// used as a default template parameter. -// 06 Feb 2001 - Removed useless #includes of standard library headers -// (David Abrahams) - #ifndef ITERATOR_DWA122600_HPP_ -# define ITERATOR_DWA122600_HPP_ - -# include -# include - -// STLPort 4.0 and betas have a bug when debugging is enabled and there is no -// partial specialization: instead of an iterator_category typedef, the standard -// container iterators have _Iterator_category. -// -// Also, whether debugging is enabled or not, there is a broken specialization -// of std::iterator which has no -// typedefs but iterator_category. -# if defined(__SGI_STL_PORT) - -# if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG) -# define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF -# endif - -# define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION - -# endif // STLPort <= 4.1b4 && no partial specialization - -# if !defined(BOOST_NO_STD_ITERATOR_TRAITS) \ - && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ - && !defined(BOOST_MSVC_STD_ITERATOR) - -namespace boost { namespace detail { - -// Define a new template so it can be specialized -template -struct iterator_traits - : std::iterator_traits -{}; -using std::distance; - -}} // namespace boost::detail - -# else - -# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ - && !defined(BOOST_MSVC_STD_ITERATOR) - -// This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS - -namespace boost { namespace detail { - -// Rogue Wave Standard Library fools itself into thinking partial -// specialization is missing on some platforms (e.g. Sun), so fails to -// supply iterator_traits! -template -struct iterator_traits -{ - typedef typename Iterator::value_type value_type; - typedef typename Iterator::reference reference; - typedef typename Iterator::pointer pointer; - typedef typename Iterator::difference_type difference_type; - typedef typename Iterator::iterator_category iterator_category; -}; - -template -struct iterator_traits -{ - typedef T value_type; - typedef T& reference; - typedef T* pointer; - typedef std::ptrdiff_t difference_type; - typedef std::random_access_iterator_tag iterator_category; -}; - -template -struct iterator_traits -{ - typedef T value_type; - typedef T const& reference; - typedef T const* pointer; - typedef std::ptrdiff_t difference_type; - typedef std::random_access_iterator_tag iterator_category; -}; - -}} // namespace boost::detail - -# else - -# include -# include -# include - -# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# include -# include -# endif -# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION -# include -# endif - -# include -# include -# include - -// should be the last #include -# include "boost/type_traits/detail/bool_trait_def.hpp" - -namespace boost { namespace detail { - -BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type) -BOOST_MPL_HAS_XXX_TRAIT_DEF(reference) -BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer) -BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type) -BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category) - -// is_mutable_iterator -- -// -// A metafunction returning true iff T is a mutable iterator type -// with a nested value_type. Will only work portably with iterators -// whose operator* returns a reference, but that seems to be OK for -// the iterators supplied by Dinkumware. Some input iterators may -// compile-time if they arrive here, and if the compiler is strict -// about not taking the address of an rvalue. - -// This one detects ordinary mutable iterators - the result of -// operator* is convertible to the value_type. -template -type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*); - -// Since you can't take the address of an rvalue, the guts of -// is_mutable_iterator_impl will fail if we use &*t directly. This -// makes sure we can still work with non-lvalue iterators. -template T* mutable_iterator_lvalue_helper(T& x); -int mutable_iterator_lvalue_helper(...); - - -// This one detects output iterators such as ostream_iterator which -// return references to themselves. -template -type_traits::yes_type is_mutable_iterator_helper(T const*, T const*); - -type_traits::no_type is_mutable_iterator_helper(...); - -template -struct is_mutable_iterator_impl -{ - static T t; - - BOOST_STATIC_CONSTANT( - bool, value = sizeof( - detail::is_mutable_iterator_helper( - (T*)0 - , mutable_iterator_lvalue_helper(*t) // like &*t - )) - == sizeof(type_traits::yes_type) - ); -}; - -BOOST_TT_AUX_BOOL_TRAIT_DEF1( - is_mutable_iterator,T,::boost::detail::is_mutable_iterator_impl::value) - - -// is_full_iterator_traits -- -// -// A metafunction returning true iff T has all the requisite nested -// types to satisfy the requirements for a fully-conforming -// iterator_traits implementation. -template -struct is_full_iterator_traits_impl -{ - enum { value = - has_value_type::value - & has_reference::value - & has_pointer::value - & has_difference_type::value - & has_iterator_category::value - }; -}; - -BOOST_TT_AUX_BOOL_TRAIT_DEF1( - is_full_iterator_traits,T,::boost::detail::is_full_iterator_traits_impl::value) +#define ITERATOR_DWA122600_HPP_ +// This header is obsolete and will be deprecated. -# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF -BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category) - -// is_stlport_40_debug_iterator -- -// -// A metafunction returning true iff T has all the requisite nested -// types to satisfy the requirements of an STLPort 4.0 debug iterator -// iterator_traits implementation. -template -struct is_stlport_40_debug_iterator_impl -{ - enum { value = - has_value_type::value - & has_reference::value - & has_pointer::value - & has_difference_type::value - & has__Iterator_category::value - }; -}; - -BOOST_TT_AUX_BOOL_TRAIT_DEF1( - is_stlport_40_debug_iterator,T,::boost::detail::is_stlport_40_debug_iterator_impl::value) - -template -struct stlport_40_debug_iterator_traits -{ - typedef typename T::value_type value_type; - typedef typename T::reference reference; - typedef typename T::pointer pointer; - typedef typename T::difference_type difference_type; - typedef typename T::_Iterator_category iterator_category; -}; -# endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF - -template struct pointer_iterator_traits; - -# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -template -struct pointer_iterator_traits -{ - typedef typename remove_const::type value_type; - typedef T* pointer; - typedef T& reference; - typedef std::random_access_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; -}; -# else - -// In case of no template partial specialization, and if T is a -// pointer, iterator_traits::value_type can still be computed. For -// some basic types, remove_pointer is manually defined in -// type_traits/broken_compiler_spec.hpp. For others, do it yourself. - -template class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee; - -template -struct pointer_value_type - : mpl::if_< - is_same::type> - , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee

- , typename remove_const< - typename remove_pointer

::type - >::type - > -{ -}; - - -template -struct pointer_reference - : mpl::if_< - is_same::type> - , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee

- , typename remove_pointer

::type& - > -{ -}; - -template -struct pointer_iterator_traits -{ - typedef T pointer; - typedef std::random_access_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - - typedef typename pointer_value_type::type value_type; - typedef typename pointer_reference::type reference; -}; - -# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -// We'll sort iterator types into one of these classifications, from which we -// can determine the difference_type, pointer, reference, and value_type -template -struct standard_iterator_traits -{ - typedef typename Iterator::difference_type difference_type; - typedef typename Iterator::value_type value_type; - typedef typename Iterator::pointer pointer; - typedef typename Iterator::reference reference; - typedef typename Iterator::iterator_category iterator_category; -}; - -template -struct msvc_stdlib_mutable_traits - : std::iterator_traits -{ - typedef typename std::iterator_traits::distance_type difference_type; - typedef typename std::iterator_traits::value_type* pointer; - typedef typename std::iterator_traits::value_type& reference; -}; +#include -template -struct msvc_stdlib_const_traits - : std::iterator_traits +namespace boost { - typedef typename std::iterator_traits::distance_type difference_type; - typedef const typename std::iterator_traits::value_type* pointer; - typedef const typename std::iterator_traits::value_type& reference; -}; -# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION -template -struct is_bad_output_iterator - : is_base_and_derived< - std::iterator - , Iterator> +namespace detail { -}; -struct bad_output_iterator_traits -{ - typedef void value_type; - typedef void difference_type; - typedef std::output_iterator_tag iterator_category; - typedef void pointer; - typedef void reference; -}; -# endif - -// If we're looking at an MSVC6 (old Dinkumware) ``standard'' -// iterator, this will generate an appropriate traits class. -template -struct msvc_stdlib_iterator_traits - : mpl::if_< - is_mutable_iterator - , msvc_stdlib_mutable_traits - , msvc_stdlib_const_traits - >::type -{}; - -template -struct non_pointer_iterator_traits - : mpl::if_< - // if the iterator contains all the right nested types... - is_full_iterator_traits - // Use a standard iterator_traits implementation - , standard_iterator_traits -# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF - // Check for STLPort 4.0 broken _Iterator_category type - , mpl::if_< - is_stlport_40_debug_iterator - , stlport_40_debug_iterator_traits -# endif - // Otherwise, assume it's a Dinkum iterator - , msvc_stdlib_iterator_traits -# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF - >::type -# endif - >::type -{ -}; - -template -struct iterator_traits_aux - : mpl::if_< - is_pointer - , pointer_iterator_traits - , non_pointer_iterator_traits - >::type -{ -}; - -template -struct iterator_traits -{ - // Explicit forwarding from base class needed to keep MSVC6 happy - // under some circumstances. - private: -# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION - typedef - typename mpl::if_< - is_bad_output_iterator - , bad_output_iterator_traits - , iterator_traits_aux - >::type base; -# else - typedef iterator_traits_aux base; -# endif - public: - typedef typename base::value_type value_type; - typedef typename base::pointer pointer; - typedef typename base::reference reference; - typedef typename base::difference_type difference_type; - typedef typename base::iterator_category iterator_category; -}; - -// This specialization cuts off ETI (Early Template Instantiation) for MSVC. -template <> struct iterator_traits -{ - typedef int value_type; - typedef int pointer; - typedef int reference; - typedef int difference_type; - typedef int iterator_category; -}; - -}} // namespace boost::detail - -# endif // workarounds - -namespace boost { namespace detail { - -namespace iterator_traits_ -{ - template - struct distance_select - { - static Difference execute(Iterator i1, const Iterator i2, ...) - { - Difference result = 0; - while (i1 != i2) - { - ++i1; - ++result; - } - return result; - } - - static Difference execute(Iterator i1, const Iterator i2, std::random_access_iterator_tag*) - { - return i2 - i1; - } - }; -} // namespace boost::detail::iterator_traits_ - -template -inline typename iterator_traits::difference_type -distance(Iterator first, Iterator last) -{ - typedef typename iterator_traits::difference_type diff_t; - typedef typename ::boost::detail::iterator_traits::iterator_category iterator_category; - - return iterator_traits_::distance_select::execute( - first, last, (iterator_category*)0); -} - -}} - -# endif +using std::iterator_traits; +using std::distance; +} // namespace detail -# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF -# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION +} // namespace boost #endif // ITERATOR_DWA122600_HPP_ diff --git a/src/thirdparty/boost_lib/boost/detail/lightweight_test.hpp b/src/thirdparty/boost_lib/boost/detail/lightweight_test.hpp index 49dd5e45d..9fece8ab7 100644 --- a/src/thirdparty/boost_lib/boost/detail/lightweight_test.hpp +++ b/src/thirdparty/boost_lib/boost/detail/lightweight_test.hpp @@ -1,208 +1,17 @@ -#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED -#define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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) + */ -// MS compatible compilers support #pragma once +#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP +#define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -// -// boost/detail/lightweight_test.hpp - lightweight test library -// -// Copyright (c) 2002, 2009 Peter Dimov -// Copyright (2) Beman Dawes 2010, 2011 -// Copyright (3) Ion Gaztanaga 2013 -// -// 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 -// -// --------------- -// -// If expression is false increases the error count -// and outputs a message containing 'expression' -// -// BOOST_TEST(expression) -// -// --------------- -// -// Increases error count and outputs a message containing 'message' -// -// BOOST_ERROR(message) -// -// --------------- -// -// If 'expr1' != 'expr2' increases the error count -// and outputs a message containing both expressions -// -// BOOST_TEST_EQ(expr1, expr2) -// -// --------------- -// -// If 'expr1' == 'expr2' increases the error count -// and outputs a message containing both expressions -// -// BOOST_TEST_NE(expr1, expr2) -// -// --------------- -// -// If BOOST_NO_EXCEPTIONS is NOT defined and if 'expr' does not -// throw an exception of type 'excep', increases the error count -// and outputs a message containing the expression. -// -// If BOOST_NO_EXCEPTIONS is defined, this macro expands to nothing -// and 'expr' is not evaluated. -// -// BOOST_TEST_THROWS(expr, excep) -// -// --------------- -// -// Returns the error count -// -// int boost::report_errors() -// - -#include -#include -#include -#include - -// IDE's like Visual Studio perform better if output goes to std::cout or -// some other stream, so allow user to configure output stream: -#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM -# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr -#endif - -namespace boost -{ - -namespace detail -{ - -struct report_errors_reminder -{ - bool called_report_errors_function; - report_errors_reminder() : called_report_errors_function(false) {} - ~report_errors_reminder() - { - BOOST_ASSERT(called_report_errors_function); // verify report_errors() was called - } -}; - -inline report_errors_reminder& report_errors_remind() -{ - static report_errors_reminder r; - return r; -} - -inline int & test_errors() -{ - static int x = 0; - report_errors_remind(); - return x; -} +// The header file at this path is deprecated; +// use boost/core/lightweight_test.hpp instead. -inline void test_failed_impl(char const * expr, char const * file, int line, char const * function) -{ - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << file << "(" << line << "): test '" << expr << "' failed in function '" - << function << "'" << std::endl; - ++test_errors(); -} +#include -inline void error_impl(char const * msg, char const * file, int line, char const * function) -{ - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << file << "(" << line << "): " << msg << " in function '" - << function << "'" << std::endl; - ++test_errors(); -} - -inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function) -{ - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << file << "(" << line << "): Exception '" << excep << "' not thrown in function '" - << function << "'" << std::endl; - ++test_errors(); -} - -template inline void test_eq_impl( char const * expr1, char const * expr2, - char const * file, int line, char const * function, T const & t, U const & u ) -{ - if( t == u ) - { - } - else - { - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << file << "(" << line << "): test '" << expr1 << " == " << expr2 - << "' failed in function '" << function << "': " - << "'" << t << "' != '" << u << "'" << std::endl; - ++test_errors(); - } -} - -template inline void test_ne_impl( char const * expr1, char const * expr2, - char const * file, int line, char const * function, T const & t, U const & u ) -{ - if( t != u ) - { - } - else - { - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << file << "(" << line << "): test '" << expr1 << " != " << expr2 - << "' failed in function '" << function << "': " - << "'" << t << "' == '" << u << "'" << std::endl; - ++test_errors(); - } -} - -} // namespace detail - -inline int report_errors() -{ - detail::report_errors_remind().called_report_errors_function = true; - - int errors = detail::test_errors(); - - if( errors == 0 ) - { - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << "No errors detected." << std::endl; - return 0; - } - else - { - BOOST_LIGHTWEIGHT_TEST_OSTREAM - << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl; - return 1; - } -} - -} // namespace boost - -#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)) -#define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) -#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) ) -#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) ) -#ifndef BOOST_NO_EXCEPTIONS - #define BOOST_TEST_THROWS( EXPR, EXCEP ) \ - try { \ - EXPR; \ - ::boost::detail::throw_failed_impl \ - (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \ - } \ - catch(EXCEP const&) { \ - } \ - catch(...) { \ - ::boost::detail::throw_failed_impl \ - (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \ - } \ - // -#else - #define BOOST_TEST_THROWS( EXPR, EXCEP ) #endif - -#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/detail/limits.hpp b/src/thirdparty/boost_lib/boost/detail/limits.hpp deleted file mode 100644 index 6f018dfac..000000000 --- a/src/thirdparty/boost_lib/boost/detail/limits.hpp +++ /dev/null @@ -1,449 +0,0 @@ -// Copyright 2001 John Maddock -// Distributed under the Boost Software License, Version 1.0. (See accompany- -// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -/* - * Copyright (c) 1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -/* NOTE: This is not portable code. Parts of numeric_limits<> are - * inherently machine-dependent, and this file is written for the MIPS - * architecture and the SGI MIPSpro C++ compiler. Parts of it (in - * particular, some of the characteristics of floating-point types) - * are almost certainly incorrect for any other platform. - */ - -/* The above comment is almost certainly out of date. This file works - * on systems other than SGI MIPSpro C++ now. - */ - -/* - * Revision history: - * 21 Sep 2001: - * Only include if BOOST_NO_CWCHAR is defined. (Darin Adler) - * 10 Aug 2001: - * Added MIPS (big endian) to the big endian family. (Jens Maurer) - * 13 Apr 2001: - * Added powerpc to the big endian family. (Jeremy Siek) - * 5 Apr 2001: - * Added sparc (big endian) processor support (John Maddock). - * Initial sub: - * Modified by Jens Maurer for gcc 2.95 on x86. - */ - -#ifndef BOOST_SGI_CPP_LIMITS -#define BOOST_SGI_CPP_LIMITS - -#include -#include -#include -#include - -#ifndef BOOST_NO_CWCHAR -#include // for WCHAR_MIN and WCHAR_MAX -#endif - -namespace std { - -enum float_round_style { - round_indeterminate = -1, - round_toward_zero = 0, - round_to_nearest = 1, - round_toward_infinity = 2, - round_toward_neg_infinity = 3 -}; - -enum float_denorm_style { - denorm_indeterminate = -1, - denorm_absent = 0, - denorm_present = 1 -}; - -// The C++ standard (section 18.2.1) requires that some of the members of -// numeric_limits be static const data members that are given constant- -// initializers within the class declaration. On compilers where the -// BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro is defined, it is impossible to write -// a standard-conforming numeric_limits class. -// -// There are two possible workarounds: either initialize the data -// members outside the class, or change them from data members to -// enums. Neither workaround is satisfactory: the former makes it -// impossible to use the data members in constant-expressions, and the -// latter means they have the wrong type and that it is impossible to -// take their addresses. We choose the former workaround. - -#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION -# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \ - enum { __mem_name = __mem_value } -#else /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */ -# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \ - static const __mem_type __mem_name = __mem_value -#endif /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */ - -// Base class for all specializations of numeric_limits. -template -class _Numeric_limits_base { -public: - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false); - - static __number min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); } - static __number max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); } - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, 0); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, 0); - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, false); - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 0); - - static __number epsilon() throw() { return __number(); } - static __number round_error() throw() { return __number(); } - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, 0); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, 0); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0); - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style, - has_denorm, - denorm_absent); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false); - - static __number infinity() throw() { return __number(); } - static __number quiet_NaN() throw() { return __number(); } - static __number signaling_NaN() throw() { return __number(); } - static __number denorm_min() throw() { return __number(); } - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false); - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false); - BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, - round_style, - round_toward_zero); -}; - -// Base class for integers. - -template -class _Integer_limits : public _Numeric_limits_base<_Int> -{ -public: - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true); - - static _Int min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imin; } - static _Int max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imax; } - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, - digits, - (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT) - - (__imin == 0 ? 0 : 1) - : __idigits); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000); - // log 2 = 0.301029995664... - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2); - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true); -}; - -#if defined(BOOST_BIG_ENDIAN) - - template - struct float_helper{ - static Number get_word() throw() { - // sizeof(long double) == 16 - const unsigned int _S_word[4] = { Word, 0, 0, 0 }; - return *reinterpret_cast(&_S_word); - } -}; - -#else - - template - struct float_helper{ - static Number get_word() throw() { - // sizeof(long double) == 12, but only 10 bytes significant - const unsigned int _S_word[4] = { 0, 0, 0, Word }; - return *reinterpret_cast( - reinterpret_cast(&_S_word)+16- - (sizeof(Number) == 12 ? 10 : sizeof(Number))); - } -}; - -#endif - -// Base class for floating-point numbers. -template -class _Floating_limits : public _Numeric_limits_base<__number> -{ -public: - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true); - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, __Digits); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10); - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true); - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2); - - BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, __MinExp); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, __MaxExp); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10); - BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10); - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style, - has_denorm, - denorm_indeterminate); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false); - - - static __number infinity() throw() { - return float_helper<__number, __InfinityWord>::get_word(); - } - static __number quiet_NaN() throw() { - return float_helper<__number,__QNaNWord>::get_word(); - } - static __number signaling_NaN() throw() { - return float_helper<__number,__SNaNWord>::get_word(); - } - - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, __IsIEC559); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false /* was: true */ ); - BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false); - - BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle); -}; - -// Class numeric_limits - -// The unspecialized class. - -template -class numeric_limits : public _Numeric_limits_base {}; - -// Specializations for all built-in integral types. - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -#ifndef BOOST_NO_INTRINSIC_WCHAR_T -template<> -class numeric_limits -#if !defined(WCHAR_MAX) || !defined(WCHAR_MIN) -#if defined(_WIN32) || defined(__CYGWIN__) - : public _Integer_limits -#elif defined(__hppa) -// wchar_t has "unsigned int" as the underlying type - : public _Integer_limits -#else -// assume that wchar_t has "int" as the underlying type - : public _Integer_limits -#endif -#else -// we have WCHAR_MIN and WCHAR_MAX defined, so use it - : public _Integer_limits -#endif -{}; -#endif - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -template<> -class numeric_limits - : public _Integer_limits -{}; - -#ifdef __GNUC__ - -// Some compilers have long long, but don't define the -// LONGLONG_MIN and LONGLONG_MAX macros in limits.h. This -// assumes that long long is 64 bits. -#if !defined(LONGLONG_MAX) && !defined(ULONGLONG_MAX) - -# define ULONGLONG_MAX 0xffffffffffffffffLLU -# define LONGLONG_MAX 0x7fffffffffffffffLL - -#endif - -#if !defined(LONGLONG_MIN) -# define LONGLONG_MIN (-LONGLONG_MAX - 1) -#endif - - -#if !defined(ULONGLONG_MIN) -# define ULONGLONG_MIN 0 -#endif - -#endif /* __GNUC__ */ - -// Specializations for all built-in floating-point type. - -template<> class numeric_limits - : public _Floating_limits -{ -public: - static float min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MIN; } - static float denorm_min() throw() { return FLT_MIN; } - static float max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MAX; } - static float epsilon() throw() { return FLT_EPSILON; } - static float round_error() throw() { return 0.5f; } // Units: ulps. -}; - -template<> class numeric_limits - : public _Floating_limits -{ -public: - static double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MIN; } - static double denorm_min() throw() { return DBL_MIN; } - static double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MAX; } - static double epsilon() throw() { return DBL_EPSILON; } - static double round_error() throw() { return 0.5; } // Units: ulps. -}; - -template<> class numeric_limits - : public _Floating_limits -{ -public: - static long double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MIN; } - static long double denorm_min() throw() { return LDBL_MIN; } - static long double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MAX; } - static long double epsilon() throw() { return LDBL_EPSILON; } - static long double round_error() throw() { return 4; } // Units: ulps. -}; - -} // namespace std - -#endif /* BOOST_SGI_CPP_LIMITS */ - -// Local Variables: -// mode:C++ -// End: - - - diff --git a/src/thirdparty/boost_lib/boost/detail/no_exceptions_support.hpp b/src/thirdparty/boost_lib/boost/detail/no_exceptions_support.hpp index d94e35834..7d17454a7 100644 --- a/src/thirdparty/boost_lib/boost/detail/no_exceptions_support.hpp +++ b/src/thirdparty/boost_lib/boost/detail/no_exceptions_support.hpp @@ -1,87 +1,17 @@ -#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ -#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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) + */ -#if (defined _MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif - -//---------------------------------------------------------------------- -// (C) Copyright 2004 Pavel Vozenilek. -// 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) -// -// -// This file contains helper macros used when exception support may be -// disabled (as indicated by macro BOOST_NO_EXCEPTIONS). -// -// Before picking up these macros you may consider using RAII techniques -// to deal with exceptions - their syntax can be always the same with -// or without exception support enabled. -// - -/* Example of use: - -void foo() { - BOOST_TRY { - ... - } BOOST_CATCH(const std::bad_alloc&) { - ... - BOOST_RETHROW - } BOOST_CATCH(const std::exception& e) { - ... - } - BOOST_CATCH_END -} - -With exception support enabled it will expand into: +#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP +#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP -void foo() { - { try { - ... - } catch (const std::bad_alloc&) { - ... - throw; - } catch (const std::exception& e) { - ... - } - } -} +// The header file at this path is deprecated; +// use boost/core/no_exceptions_support.hpp instead. -With exception support disabled it will expand into: +#include -void foo() { - { if(true) { - ... - } else if (false) { - ... - } else if (false) { - ... - } - } -} -*/ -//---------------------------------------------------------------------- - -#include -#include - -#if !(defined BOOST_NO_EXCEPTIONS) -# define BOOST_TRY { try -# define BOOST_CATCH(x) catch(x) -# define BOOST_RETHROW throw; -# define BOOST_CATCH_END } -#else -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -# define BOOST_TRY { if ("") -# define BOOST_CATCH(x) else if (!"") -# else -# define BOOST_TRY { if (true) -# define BOOST_CATCH(x) else if (false) -# endif -# define BOOST_RETHROW -# define BOOST_CATCH_END } #endif - - -#endif diff --git a/src/thirdparty/boost_lib/boost/detail/none_t.hpp b/src/thirdparty/boost_lib/boost/detail/none_t.hpp deleted file mode 100644 index 40805ec0f..000000000 --- a/src/thirdparty/boost_lib/boost/detail/none_t.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright (C) 2003, Fernando Luis Cacciola Carballal. -// -// Use, modification, and distribution is subject to the Boost Software -// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/optional for documentation. -// -// You are welcome to contact the author at: -// fernando_cacciola@hotmail.com -// -#ifndef BOOST_DETAIL_NONE_T_17SEP2003_HPP -#define BOOST_DETAIL_NONE_T_17SEP2003_HPP - -namespace boost { - -namespace detail { - -struct none_helper{}; - -typedef int none_helper::*none_t ; - -} // namespace detail - -} // namespace boost - -#endif - diff --git a/src/thirdparty/boost_lib/boost/detail/numeric_traits.hpp b/src/thirdparty/boost_lib/boost/detail/numeric_traits.hpp index 6325d70cb..2f97ebf9c 100644 --- a/src/thirdparty/boost_lib/boost/detail/numeric_traits.hpp +++ b/src/thirdparty/boost_lib/boost/detail/numeric_traits.hpp @@ -74,7 +74,7 @@ namespace boost { namespace detail { template struct is_signed { -#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300 +#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0))); #else BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits::is_signed); @@ -128,15 +128,6 @@ namespace boost { namespace detail { private: typedef Integer integer_type; typedef std::numeric_limits x; -# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 - // for some reason, MSVC asserts when it shouldn't unless we make these - // local definitions - BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer); - BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized); - - BOOST_STATIC_ASSERT(is_integer); - BOOST_STATIC_ASSERT(is_specialized); -# endif public: typedef typename if_true<(int(x::is_signed) diff --git a/src/thirdparty/boost_lib/boost/detail/ob_call_traits.hpp b/src/thirdparty/boost_lib/boost/detail/ob_call_traits.hpp deleted file mode 100644 index eb4df7a30..000000000 --- a/src/thirdparty/boost_lib/boost/detail/ob_call_traits.hpp +++ /dev/null @@ -1,168 +0,0 @@ -// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. -// 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). -// -// See http://www.boost.org/libs/utility for most recent version including documentation. -// -// Crippled version for crippled compilers: -// see libs/utility/call_traits.htm -// - -/* Release notes: - 01st October 2000: - Fixed call_traits on VC6, using "poor man's partial specialisation", - using ideas taken from "Generative programming" by Krzysztof Czarnecki - & Ulrich Eisenecker. -*/ - -#ifndef BOOST_OB_CALL_TRAITS_HPP -#define BOOST_OB_CALL_TRAITS_HPP - -#ifndef BOOST_CONFIG_HPP -#include -#endif - -#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP -#include -#endif -#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP -#include -#endif - -namespace boost{ - -#ifdef BOOST_MSVC6_MEMBER_TEMPLATES -// -// use member templates to emulate -// partial specialisation: -// -namespace detail{ - -template -struct standard_call_traits -{ - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& param_type; -}; -template -struct simple_call_traits -{ - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T param_type; -}; -template -struct reference_call_traits -{ - typedef T value_type; - typedef T reference; - typedef T const_reference; - typedef T param_type; -}; - -template -struct call_traits_chooser -{ - template - struct rebind - { - typedef standard_call_traits type; - }; -}; - -template <> -struct call_traits_chooser -{ - template - struct rebind - { - typedef simple_call_traits type; - }; -}; - -template <> -struct call_traits_chooser -{ - template - struct rebind - { - typedef reference_call_traits type; - }; -}; - -template -struct call_traits_sizeof_chooser2 -{ - template - struct small_rebind - { - typedef simple_call_traits small_type; - }; -}; - -template<> -struct call_traits_sizeof_chooser2 -{ - template - struct small_rebind - { - typedef standard_call_traits small_type; - }; -}; - -template <> -struct call_traits_chooser -{ - template - struct rebind - { - enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) }; - typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser; - typedef typename chooser::template small_rebind bound_type; - typedef typename bound_type::small_type type; - }; -}; - -} // namespace detail -template -struct call_traits -{ -private: - typedef detail::call_traits_chooser< - ::boost::is_pointer::value, - ::boost::is_arithmetic::value, - ::boost::is_reference::value - > chooser; - typedef typename chooser::template rebind bound_type; - typedef typename bound_type::type call_traits_type; -public: - typedef typename call_traits_type::value_type value_type; - typedef typename call_traits_type::reference reference; - typedef typename call_traits_type::const_reference const_reference; - typedef typename call_traits_type::param_type param_type; -}; - -#else -// -// sorry call_traits is completely non-functional -// blame your broken compiler: -// - -template -struct call_traits -{ - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& param_type; -}; - -#endif // member templates - -} - -#endif // BOOST_OB_CALL_TRAITS_HPP diff --git a/src/thirdparty/boost_lib/boost/detail/ob_compressed_pair.hpp b/src/thirdparty/boost_lib/boost/detail/ob_compressed_pair.hpp index 727acab6d..326e45498 100644 --- a/src/thirdparty/boost_lib/boost/detail/ob_compressed_pair.hpp +++ b/src/thirdparty/boost_lib/boost/detail/ob_compressed_pair.hpp @@ -167,17 +167,6 @@ class compressed_pair_1 : T2 compressed_pair_1(const ::boost::compressed_pair& x) : T2(x.second()), _first(x.first()) {} -#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 - // Total weirdness. If the assignment to _first is moved after - // the call to the inherited operator=, then this breaks graph/test/graph.cpp - // by way of iterator_adaptor. - compressed_pair_1& operator=(const compressed_pair_1& x) { - _first = x._first; - T2::operator=(x); - return *this; - } -#endif - first_reference first() { return _first; } first_const_reference first() const { return _first; } diff --git a/src/thirdparty/boost_lib/boost/detail/reference_content.hpp b/src/thirdparty/boost_lib/boost/detail/reference_content.hpp index daf56a8b1..36b80d244 100644 --- a/src/thirdparty/boost_lib/boost/detail/reference_content.hpp +++ b/src/thirdparty/boost_lib/boost/detail/reference_content.hpp @@ -15,13 +15,8 @@ #include "boost/config.hpp" -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include "boost/mpl/bool.hpp" # include "boost/type_traits/has_nothrow_copy.hpp" -#else -# include "boost/mpl/if.hpp" -# include "boost/type_traits/is_reference.hpp" -#endif #include "boost/mpl/void.hpp" @@ -78,7 +73,6 @@ class reference_content template struct make_reference_content; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template struct make_reference_content @@ -92,19 +86,6 @@ struct make_reference_content< T& > typedef reference_content type; }; -#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -template -struct make_reference_content - : mpl::if_< - is_reference - , reference_content - , T - > -{ -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround template <> struct make_reference_content< mpl::void_ > @@ -124,7 +105,6 @@ struct make_reference_content< mpl::void_ > // reference_content type traits specializations // -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template struct has_nothrow_copy< @@ -134,7 +114,6 @@ struct has_nothrow_copy< { }; -#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/detail/scoped_enum_emulation.hpp b/src/thirdparty/boost_lib/boost/detail/scoped_enum_emulation.hpp index d266e0e33..1c7bc23c1 100644 --- a/src/thirdparty/boost_lib/boost/detail/scoped_enum_emulation.hpp +++ b/src/thirdparty/boost_lib/boost/detail/scoped_enum_emulation.hpp @@ -1,337 +1,17 @@ -// scoped_enum_emulation.hpp ---------------------------------------------------------// - -// Copyright Beman Dawes, 2009 -// Copyright (C) 2011-2012 Vicente J. Botet Escriba -// Copyright (C) 2012 Anthony Williams - -// Distributed under the Boost Software License, Version 1.0. -// See http://www.boost.org/LICENSE_1_0.txt - /* -[section:scoped_enums Scoped Enums] - -Generates C++0x scoped enums if the feature is present, otherwise emulates C++0x -scoped enums with C++03 namespaces and enums. The Boost.Config BOOST_NO_CXX11_SCOPED_ENUMS -macro is used to detect feature support. - -See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a -description of the scoped enum feature. Note that the committee changed the name -from strongly typed enum to scoped enum. - -Some of the enumerations defined in the standard library are scoped enums. - - enum class future_errc - { - broken_promise, - future_already_retrieved, - promise_already_satisfied, - no_state - }; - -On compilers that don't support them, the library provides two emulations: - -[heading Strict] - -* Able to specify the underlying type. -* explicit conversion to/from underlying type. -* The wrapper is not a C++03 enum type. - -The user can declare declare these types as - - BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_errc) - { - broken_promise, - future_already_retrieved, - promise_already_satisfied, - no_state - } - BOOST_SCOPED_ENUM_DECLARE_END(future_errc) - -These macros allows to use 'future_errc' in almost all the cases as an scoped enum. - - future_errc err = future_errc::no_state; - -There are however some limitations: - -* The type is not a C++ enum, so 'is_enum' will be false_type. -* The emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some macros. - -Instead of - - switch (ev) - { - case future_errc::broken_promise: - // ... - -use - - switch (boost::native_value(ev)) - { - case future_errc::broken_promise: - -And instead of - - #ifdef BOOST_NO_CXX11_SCOPED_ENUMS - template <> - struct BOOST_SYMBOL_VISIBLE is_error_code_enum : public true_type { }; - #endif - -use - - #ifdef BOOST_NO_CXX11_SCOPED_ENUMS - template <> - struct BOOST_SYMBOL_VISIBLE is_error_code_enum : public true_type { }; - #endif - - -Sample usage: - - BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(algae, char) { green, red, cyan }; BOOST_SCOPED_ENUM_DECLARE_END(algae) - ... - algae sample( algae::red ); - void foo( algae color ); - ... - sample = algae::green; - foo( algae::cyan ); - - Light - Caution: only the syntax is emulated; the semantics are not emulated and - the syntax emulation doesn't include being able to specify the underlying - representation type. - - The literal scoped emulation is via struct rather than namespace to allow use within classes. - Thanks to Andrey Semashev for pointing that out. - However the type is an real C++03 enum and so convertible implicitly to an int. - - Sample usage: - - BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END - ... - BOOST_SCOPED_ENUM(algae) sample( algae::red ); - void foo( BOOST_SCOPED_ENUM(algae) color ); - ... - sample = algae::green; - foo( algae::cyan ); - - Helpful comments and suggestions were also made by Kjell Elster, Phil Endecott, - Joel Falcou, Mathias Gaunard, Felipe Magno de Almeida, Matt Calabrese, Vicente - Botet, and Daniel James. - -[endsect] -*/ - - -#ifndef BOOST_SCOPED_ENUM_EMULATION_HPP -#define BOOST_SCOPED_ENUM_EMULATION_HPP - -#include -#include - -namespace boost -{ - -#ifdef BOOST_NO_CXX11_SCOPED_ENUMS - /** - * Meta-function to get the underlying type of a scoped enum. - * - * Requires EnumType must be an enum type or the emulation of a scoped enum - */ - template - struct underlying_type - { - /** - * The member typedef type names the underlying type of EnumType. It is EnumType::underlying_type when the EnumType is an emulated scoped enum, - * std::underlying_type::type when the standard library std::underlying_type is provided. - * - * The user will need to specialize it when the compiler supports scoped enums but don't provides std::underlying_type. - */ - typedef typename EnumType::underlying_type type; - }; - - /** - * Meta-function to get the native enum type associated to an enum class or its emulation. - */ - template - struct native_type - { - /** - * The member typedef type names the native enum type associated to the scoped enum, - * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum. - */ - typedef typename EnumType::enum_type type; - }; - - /** - * Casts a scoped enum to its underlying type. - * - * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type. - * @param v A scoped enum. - * @returns The underlying type. - * @throws No-throws. - */ - template - UnderlyingType underlying_cast(EnumType v) - { - return v.get_underlying_value_(); - } - - /** - * Casts a scoped enum to its native enum type. - * - * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can. - * - * EnumType the scoped enum type - * - * @param v A scoped enum. - * @returns The native enum value. - * @throws No-throws. - */ - template - inline - typename EnumType::enum_type native_value(EnumType e) - { - return e.native_value_(); - } - -#else // BOOST_NO_CXX11_SCOPED_ENUMS - - template - struct underlying_type - { - //typedef typename std::underlying_type::type type; - }; - - template - struct native_type - { - typedef EnumType type; - }; - - template - UnderlyingType underlying_cast(EnumType v) - { - return static_cast(v); - } - - template - inline - EnumType native_value(EnumType e) - { - return e; - } - -#endif -} - - -#ifdef BOOST_NO_CXX11_SCOPED_ENUMS - -#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS - -#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \ - explicit operator underlying_type() const { return get_underlying_value_(); } - -#else - -#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR - -#endif - -/** - * Start a declaration of a scoped enum. + * Copyright (c) 2014 Andrey Semashev * - * @param EnumType The new scoped enum. - * @param UnderlyingType The underlying type. + * 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) */ -#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType) \ - struct EnumType { \ - typedef UnderlyingType underlying_type; \ - EnumType() BOOST_NOEXCEPT {} \ - explicit EnumType(underlying_type v) : v_(v) {} \ - underlying_type get_underlying_value_() const { return v_; } \ - BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \ - private: \ - underlying_type v_; \ - typedef EnumType self_type; \ - public: \ - enum enum_type -#define BOOST_SCOPED_ENUM_DECLARE_END2() \ - enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \ - operator enum_type() const BOOST_NOEXCEPT { return get_native_value_(); } \ - friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \ - friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \ - friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \ - friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \ - friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \ - friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \ - friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \ - friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \ - friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \ - friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \ - friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \ - friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \ - }; +#ifndef BOOST_DETAIL_SCOPED_ENUM_EMULATION_HPP +#define BOOST_DETAIL_SCOPED_ENUM_EMULATION_HPP -#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \ - ; \ - EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {} \ - BOOST_SCOPED_ENUM_DECLARE_END2() +// The header file at this path is deprecated; +// use boost/core/scoped_enum.hpp instead. -/** - * Starts a declaration of a scoped enum with the default int underlying type. - * - * @param EnumType The new scoped enum. - */ -#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \ - BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int) +#include -/** - * Name of the native enum type. - * - * @param NT The new scoped enum. - */ -#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type -/** - * Forward declares an scoped enum. - * - * @param NT The scoped enum. - */ -#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType - -#else // BOOST_NO_CXX11_SCOPED_ENUMS - -#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType:UnderlyingType -#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType -#define BOOST_SCOPED_ENUM_DECLARE_END2() -#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ; - -#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType -#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType - -#endif // BOOST_NO_CXX11_SCOPED_ENUMS - -#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name) -#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2() -#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name) - -//#ifdef BOOST_NO_CXX11_SCOPED_ENUMS -// -//# define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type -//# define BOOST_SCOPED_ENUM_END }; -//# define BOOST_SCOPED_ENUM(name) name::enum_type -// -//#else -// -//# define BOOST_SCOPED_ENUM_START(name) enum class name -//# define BOOST_SCOPED_ENUM_END -//# define BOOST_SCOPED_ENUM(name) name -// -//#endif -#endif // BOOST_SCOPED_ENUM_EMULATION_HPP +#endif diff --git a/src/thirdparty/boost_lib/boost/detail/sp_typeinfo.hpp b/src/thirdparty/boost_lib/boost/detail/sp_typeinfo.hpp index 43fae78ef..4e4de55b0 100644 --- a/src/thirdparty/boost_lib/boost/detail/sp_typeinfo.hpp +++ b/src/thirdparty/boost_lib/boost/detail/sp_typeinfo.hpp @@ -9,104 +9,15 @@ // detail/sp_typeinfo.hpp // +// Deprecated, please use boost/core/typeinfo.hpp +// // Copyright 2007 Peter Dimov // -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include - -#if defined( BOOST_NO_TYPEID ) - -#include -#include - -namespace boost -{ - -namespace detail -{ - -class sp_typeinfo -{ -private: - - sp_typeinfo( sp_typeinfo const& ); - sp_typeinfo& operator=( sp_typeinfo const& ); - - char const * name_; - -public: - - explicit sp_typeinfo( char const * name ): name_( name ) - { - } - - bool operator==( sp_typeinfo const& rhs ) const - { - return this == &rhs; - } - - bool operator!=( sp_typeinfo const& rhs ) const - { - return this != &rhs; - } - - bool before( sp_typeinfo const& rhs ) const - { - return std::less< sp_typeinfo const* >()( this, &rhs ); - } - - char const* name() const - { - return name_; - } -}; - -template struct sp_typeid_ -{ - static sp_typeinfo ti_; - - static char const * name() - { - return BOOST_CURRENT_FUNCTION; - } -}; +// 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) -#if defined(__SUNPRO_CC) -// see #4199, the Sun Studio compiler gets confused about static initialization -// constructor arguments. But an assignment works just fine. -template sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name(); -#else -template sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name()); -#endif - -template struct sp_typeid_< T & >: sp_typeid_< T > -{ -}; - -template struct sp_typeid_< T const >: sp_typeid_< T > -{ -}; - -template struct sp_typeid_< T volatile >: sp_typeid_< T > -{ -}; - -template struct sp_typeid_< T const volatile >: sp_typeid_< T > -{ -}; - -} // namespace detail - -} // namespace boost - -#define BOOST_SP_TYPEID(T) (boost::detail::sp_typeid_::ti_) - -#else - -#include +#include namespace boost { @@ -114,22 +25,12 @@ namespace boost namespace detail { -#if defined( BOOST_NO_STD_TYPEINFO ) - -typedef ::type_info sp_typeinfo; - -#else - -typedef std::type_info sp_typeinfo; - -#endif +typedef boost::core::typeinfo sp_typeinfo; } // namespace detail } // namespace boost -#define BOOST_SP_TYPEID(T) typeid(T) - -#endif +#define BOOST_SP_TYPEID(T) BOOST_CORE_TYPEID(T) #endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.hpp b/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.hpp index b777ff934..753b33933 100644 --- a/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.hpp +++ b/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.hpp @@ -122,9 +122,13 @@ struct BOOST_UTF8_DECL utf8_codecvt_facet : ) const; virtual std::codecvt_base::result do_out( - std::mbstate_t & state, const wchar_t * from, - const wchar_t * from_end, const wchar_t* & from_next, - char * to, char * to_end, char * & to_next + std::mbstate_t & state, + const wchar_t * from, + const wchar_t * from_end, + const wchar_t* & from_next, + char * to, + char * to_end, + char * & to_next ) const; bool invalid_continuing_octet(unsigned char octet_1) const { @@ -137,17 +141,19 @@ struct BOOST_UTF8_DECL utf8_codecvt_facet : } // continuing octets = octets except for the leading octet - static unsigned int get_cont_octet_count(unsigned char lead_octet) { + static unsigned int get_cont_octet_count(unsigned char lead_octet) { return get_octet_count(lead_octet) - 1; } - static unsigned int get_octet_count(unsigned char lead_octet); + static unsigned int get_octet_count(unsigned char lead_octet); // How many "continuing octets" will be needed for this word // == total octets - 1. int get_cont_octet_out_count(wchar_t word) const ; - virtual bool do_always_noconv() const throw() { return false; } + virtual bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW { + return false; + } // UTF-8 isn't really stateful since we rewind on partial conversions virtual std::codecvt_base::result do_unshift( @@ -155,13 +161,12 @@ struct BOOST_UTF8_DECL utf8_codecvt_facet : char * from, char * /*to*/, char * & next - ) const - { + ) const { next = from; return ok; } - virtual int do_encoding() const throw() { + virtual int do_encoding() const BOOST_NOEXCEPT_OR_NOTHROW { const int variable_byte_external_encoding=0; return variable_byte_external_encoding; } @@ -173,14 +178,10 @@ struct BOOST_UTF8_DECL utf8_codecvt_facet : const char * from, const char * from_end, std::size_t max_limit -#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) - ) const throw(); -#else - ) const; -#endif + ) const; // Largest possible value do_length(state,from,from_end,1) could return. - virtual int do_max_length() const throw () { + virtual int do_max_length() const BOOST_NOEXCEPT_OR_NOTHROW { return 6; // largest UTF-8 encoding of a UCS-4 character } }; diff --git a/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.ipp b/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.ipp index 064fdaf58..8a1312465 100644 --- a/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.ipp +++ b/src/thirdparty/boost_lib/boost/detail/utf8_codecvt_facet.ipp @@ -171,14 +171,13 @@ std::codecvt_base::result utf8_codecvt_facet::do_out( // How many char objects can I process to get <= max_limit // wchar_t objects? int utf8_codecvt_facet::do_length( - BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &, + const std::mbstate_t &, const char * from, const char * from_end, std::size_t max_limit -#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) -) const throw() -#else ) const +#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) + throw() #endif { // RG - this code is confusing! I need a better way to express it. diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/basic_types.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/basic_types.hpp index e9ca3700a..09d907bdc 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/basic_types.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/basic_types.hpp @@ -9,9 +9,9 @@ #ifndef BOOST_DETAIL_WINAPI_BASIC_TYPES_HPP #define BOOST_DETAIL_WINAPI_BASIC_TYPES_HPP -#include #include #include +#include #if defined( BOOST_USE_WINDOWS_H ) # include @@ -31,6 +31,9 @@ # define WINAPI __stdcall # endif # endif +# ifndef NTAPI +# define NTAPI __stdcall +# endif #else # error "Win32 functions not available" #endif @@ -44,11 +47,20 @@ namespace detail { namespace winapi { #if defined( BOOST_USE_WINDOWS_H ) typedef ::BOOL BOOL_; + typedef ::BOOLEAN BOOLEAN_; + typedef ::PBOOLEAN PBOOLEAN_; + typedef ::BYTE BYTE_; typedef ::WORD WORD_; typedef ::DWORD DWORD_; typedef ::HANDLE HANDLE_; + typedef ::HMODULE HMODULE_; typedef ::LONG LONG_; + typedef ::ULONG ULONG_; typedef ::LONGLONG LONGLONG_; + typedef ::ULONGLONG ULONGLONG_; + typedef ::INT_PTR INT_PTR_; + typedef ::UINT_PTR UINT_PTR_; + typedef ::LONG_PTR LONG_PTR_; typedef ::ULONG_PTR ULONG_PTR_; typedef ::LARGE_INTEGER LARGE_INTEGER_; typedef ::PLARGE_INTEGER PLARGE_INTEGER_; @@ -63,32 +75,37 @@ namespace winapi { #else extern "C" { typedef int BOOL_; + typedef unsigned char BYTE_; + typedef BYTE_ BOOLEAN_; + typedef BOOLEAN_* PBOOLEAN_; typedef unsigned short WORD_; typedef unsigned long DWORD_; typedef void* HANDLE_; + typedef void* HMODULE_; typedef long LONG_; + typedef unsigned long ULONG_; -// @FIXME Which condition must be tested -//~ #if !defined(_M_IX86) -//~ #if defined(BOOST_NO_INT64_T) - //~ typedef double LONGLONG_; -//~ #else - //~ typedef __int64 LONGLONG_; -//~ #endif -//~ #else - //~ typedef double LONGLONG_; -//~ #endif typedef boost::int64_t LONGLONG_; + typedef boost::uint64_t ULONGLONG_; // @FIXME Which condition must be tested # ifdef _WIN64 #if defined(__CYGWIN__) + typedef long INT_PTR_; + typedef unsigned long UINT_PTR_; + typedef long LONG_PTR_; typedef unsigned long ULONG_PTR_; #else + typedef __int64 INT_PTR_; + typedef unsigned __int64 UINT_PTR_; + typedef __int64 LONG_PTR_; typedef unsigned __int64 ULONG_PTR_; #endif # else + typedef int INT_PTR_; + typedef unsigned int UINT_PTR_; + typedef long LONG_PTR_; typedef unsigned long ULONG_PTR_; # endif @@ -113,4 +130,5 @@ extern "C" { } } } -#endif // BOOST_DETAIL_WINAPI_TIME_HPP + +#endif // BOOST_DETAIL_WINAPI_BASIC_TYPES_HPP diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/config.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/config.hpp new file mode 100644 index 000000000..2b0cdfbad --- /dev/null +++ b/src/thirdparty/boost_lib/boost/detail/winapi/config.hpp @@ -0,0 +1,53 @@ +// config.hpp --------------------------------------------------------------// + +// Copyright 2013 Andrey Semashev + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WINAPI_CONFIG_HPP_INCLUDED_ +#define BOOST_DETAIL_WINAPI_CONFIG_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +// These constants reflect _WIN32_WINNT_* macros from sdkddkver.h +// See also: http://msdn.microsoft.com/en-us/library/windows/desktop/aa383745%28v=vs.85%29.aspx#setting_winver_or__win32_winnt +#define BOOST_WINAPI_VERSION_NT4 0x0400 +#define BOOST_WINAPI_VERSION_WIN2K 0x0500 +#define BOOST_WINAPI_VERSION_WINXP 0x0501 +#define BOOST_WINAPI_VERSION_WS03 0x0502 +#define BOOST_WINAPI_VERSION_WIN6 0x0600 +#define BOOST_WINAPI_VERSION_VISTA 0x0600 +#define BOOST_WINAPI_VERSION_WS08 0x0600 +#define BOOST_WINAPI_VERSION_LONGHORN 0x0600 +#define BOOST_WINAPI_VERSION_WIN7 0x0601 +#define BOOST_WINAPI_VERSION_WIN8 0x0602 +#define BOOST_WINAPI_VERSION_WINBLUE 0x0603 + +#if !defined(BOOST_USE_WINAPI_VERSION) +#if defined(_WIN32_WINNT) +#define BOOST_USE_WINAPI_VERSION _WIN32_WINNT +#elif defined(WINVER) +#define BOOST_USE_WINAPI_VERSION WINVER +#else +// By default use Windows XP API +#define BOOST_USE_WINAPI_VERSION BOOST_WINAPI_VERSION_WINXP +#endif +#endif + +#if defined(BOOST_USE_WINDOWS_H) +// We have to define the version macros so that windows.h provides the necessary symbols +#if !defined(_WIN32_WINNT) +#define _WIN32_WINNT BOOST_USE_WINAPI_VERSION +#endif +#if !defined(WINVER) +#define WINVER BOOST_USE_WINAPI_VERSION +#endif +#endif + +#endif // BOOST_DETAIL_WINAPI_CONFIG_HPP_INCLUDED_ diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/dll.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/dll.hpp index ed4527275..2ec5a73bc 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/dll.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/dll.hpp @@ -23,33 +23,64 @@ namespace detail namespace winapi { #if defined( BOOST_USE_WINDOWS_H ) - using ::LoadLibrary; + typedef ::FARPROC FARPROC_; + typedef ::NEARPROC NEARPROC_; + typedef ::PROC PROC_; + +# ifdef BOOST_NO_ANSI_APIS + using ::LoadLibraryW; + using ::GetModuleHandleW; +# else + using ::LoadLibraryA; + using ::GetModuleHandleA; +# endif using ::FreeLibrary; using ::GetProcAddress; - using ::GetModuleHandleA; #else -extern "C" { - __declspec(dllimport) HMODULE_ __stdcall - LoadLibrary( - LPCTSTR_ lpFileName +extern "C" { +# ifdef _WIN64 + typedef INT_PTR_ (WINAPI *FARPROC_)(); + typedef INT_PTR_ (WINAPI *NEARPROC_)(); + typedef INT_PTR_ (WINAPI *PROC_)(); +# else + typedef int (WINAPI *FARPROC_)(); + typedef int (WINAPI *NEARPROC_)(); + typedef int (WINAPI *PROC_)(); +# endif // _WIN64 + +# ifdef BOOST_NO_ANSI_APIS + __declspec(dllimport) HMODULE_ WINAPI + LoadLibraryW( + LPCWSTR_ lpFileName ); - __declspec(dllimport) BOOL_ __stdcall + __declspec(dllimport) HMODULE_ WINAPI + GetModuleHandleW( + LPCWSTR_ lpFileName + ); +# else + __declspec(dllimport) HMODULE_ WINAPI + LoadLibraryA( + LPCSTR_ lpFileName + ); + __declspec(dllimport) HMODULE_ WINAPI + GetModuleHandleA( + LPCSTR_ lpFileName + ); +# endif + + __declspec(dllimport) BOOL_ WINAPI FreeLibrary( HMODULE_ hModule ); - __declspec(dllimport) FARPROC_ __stdcall + __declspec(dllimport) FARPROC_ WINAPI GetProcAddress( HMODULE_ hModule, LPCSTR_ lpProcName ); - __declspec(dllimport) FARPROC_ __stdcall - GetModuleHandleA( - LPCSTR_ lpProcName - ); -} +} #endif } } } -#endif // BOOST_DETAIL_WINAPI_THREAD_HPP +#endif // BOOST_DETAIL_WINAPI_DLL_HPP diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/handles.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/handles.hpp index d4cffc803..7108daa10 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/handles.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/handles.hpp @@ -24,14 +24,20 @@ namespace winapi #if defined( BOOST_USE_WINDOWS_H ) using ::CloseHandle; using ::DuplicateHandle; + + const DWORD_ duplicate_close_source = DUPLICATE_CLOSE_SOURCE; + const DWORD_ duplicate_same_access = DUPLICATE_SAME_ACCESS; + const HANDLE_ invalid_handle_value = INVALID_HANDLE_VALUE; #else -extern "C" { - __declspec(dllimport) int __stdcall +extern "C" { + __declspec(dllimport) int __stdcall CloseHandle(void*); - __declspec(dllimport) int __stdcall + __declspec(dllimport) int __stdcall DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long); } - + const DWORD_ duplicate_close_source = 1; + const DWORD_ duplicate_same_access = 2; + const HANDLE_ invalid_handle_value = (HANDLE_)(-1); #endif } } diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/process.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/process.hpp index 411ffaf8c..de287b15f 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/process.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/process.hpp @@ -23,10 +23,9 @@ namespace winapi { using ::GetCurrentProcessId; #else # ifndef UNDER_CE -extern "C" { - __declspec(dllimport) unsigned long __stdcall - GetCurrentProcessId(void); -} +extern "C" { + __declspec(dllimport) DWORD_ WINAPI GetCurrentProcessId(void); +} # else using ::GetCurrentProcessId; # endif diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/synchronization.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/synchronization.hpp index 5d3327af0..b9497cbf7 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/synchronization.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/synchronization.hpp @@ -25,7 +25,26 @@ namespace winapi typedef ::CRITICAL_SECTION CRITICAL_SECTION_; typedef ::PAPCFUNC PAPCFUNC_; +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + typedef ::INIT_ONCE INIT_ONCE_; + typedef ::PINIT_ONCE PINIT_ONCE_; + typedef ::LPINIT_ONCE LPINIT_ONCE_; + #define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT INIT_ONCE_STATIC_INIT + typedef ::PINIT_ONCE_FN PINIT_ONCE_FN_; + + typedef ::SRWLOCK SRWLOCK_; + typedef ::PSRWLOCK PSRWLOCK_; + #define BOOST_DETAIL_WINAPI_SRWLOCK_INIT SRWLOCK_INIT + + typedef ::CONDITION_VARIABLE CONDITION_VARIABLE_; + typedef ::PCONDITION_VARIABLE PCONDITION_VARIABLE_; + #define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT CONDITION_VARIABLE_INIT +#endif + using ::InitializeCriticalSection; +#if BOOST_USE_WINAPI_VERSION >= 0x0403 + using ::InitializeCriticalSectionAndSpinCount; +#endif using ::EnterCriticalSection; using ::TryEnterCriticalSection; using ::LeaveCriticalSection; @@ -33,14 +52,18 @@ namespace winapi # ifdef BOOST_NO_ANSI_APIS using ::CreateMutexW; + using ::OpenMutexW; using ::CreateEventW; using ::OpenEventW; using ::CreateSemaphoreW; + using ::OpenSemaphoreW; # else using ::CreateMutexA; + using ::OpenMutexA; using ::CreateEventA; using ::OpenEventA; using ::CreateSemaphoreA; + using ::OpenSemaphoreA; # endif using ::ReleaseMutex; using ::ReleaseSemaphore; @@ -50,17 +73,47 @@ namespace winapi using ::WaitForSingleObject; using ::QueueUserAPC; +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + using ::InitOnceInitialize; + using ::InitOnceExecuteOnce; + using ::InitOnceBeginInitialize; + using ::InitOnceComplete; + + using ::InitializeSRWLock; + using ::AcquireSRWLockExclusive; + using ::TryAcquireSRWLockExclusive; + using ::ReleaseSRWLockExclusive; + using ::AcquireSRWLockShared; + using ::TryAcquireSRWLockShared; + using ::ReleaseSRWLockShared; + + using ::InitializeConditionVariable; + using ::WakeConditionVariable; + using ::WakeAllConditionVariable; + using ::SleepConditionVariableCS; + using ::SleepConditionVariableSRW; +#endif + const DWORD_ infinite = INFINITE; const DWORD_ wait_abandoned = WAIT_ABANDONED; const DWORD_ wait_object_0 = WAIT_OBJECT_0; const DWORD_ wait_timeout = WAIT_TIMEOUT; const DWORD_ wait_failed = WAIT_FAILED; +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + const DWORD_ init_once_async = INIT_ONCE_ASYNC; + const DWORD_ init_once_check_only = INIT_ONCE_CHECK_ONLY; + const DWORD_ init_once_init_failed = INIT_ONCE_INIT_FAILED; + const DWORD_ init_once_ctx_reserved_bits = INIT_ONCE_CTX_RESERVED_BITS; + + const ULONG_ condition_variable_lockmode_shared = CONDITION_VARIABLE_LOCKMODE_SHARED; +#endif + #else // defined( BOOST_USE_WINDOWS_H ) extern "C" { - struct CRITICAL_SECTION_ + typedef struct CRITICAL_SECTION_ { struct critical_section_debug * DebugInfo; long LockCount; @@ -72,73 +125,167 @@ extern "C" { #else unsigned long SpinCount; #endif - }; - - __declspec(dllimport) void __stdcall - InitializeCriticalSection(CRITICAL_SECTION_ *); - __declspec(dllimport) void __stdcall - EnterCriticalSection(CRITICAL_SECTION_ *); - __declspec(dllimport) bool __stdcall - TryEnterCriticalSection(CRITICAL_SECTION_ *); - __declspec(dllimport) void __stdcall - LeaveCriticalSection(CRITICAL_SECTION_ *); - __declspec(dllimport) void __stdcall - DeleteCriticalSection(CRITICAL_SECTION_ *); - - struct _SECURITY_ATTRIBUTES; + } + *PCRITICAL_SECTION_; + +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + typedef union INIT_ONCE_ + { + PVOID_ Ptr; + } + *PINIT_ONCE_, *LPINIT_ONCE_; + #define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT {0} + typedef BOOL_ (WINAPI *PINIT_ONCE_FN_)(PINIT_ONCE_ InitOnce, PVOID_ Parameter, PVOID_ *Context); + + typedef struct SRWLOCK_ + { + PVOID_ Ptr; + } + * PSRWLOCK_; + #define BOOST_DETAIL_WINAPI_SRWLOCK_INIT {0} + + typedef struct CONDITION_VARIABLE_ + { + PVOID_ Ptr; + } + * PCONDITION_VARIABLE_; + #define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT {0} + +#endif + + __declspec(dllimport) void WINAPI + InitializeCriticalSection(PCRITICAL_SECTION_); +#if BOOST_USE_WINAPI_VERSION >= 0x0403 + __declspec(dllimport) BOOL_ WINAPI + InitializeCriticalSectionAndSpinCount(CRITICAL_SECTION_* lpCS, DWORD_ dwSpinCount); +#endif + __declspec(dllimport) void WINAPI + EnterCriticalSection(PCRITICAL_SECTION_); + __declspec(dllimport) BOOL_ WINAPI + TryEnterCriticalSection(PCRITICAL_SECTION_); + __declspec(dllimport) void WINAPI + LeaveCriticalSection(PCRITICAL_SECTION_); + __declspec(dllimport) void WINAPI + DeleteCriticalSection(PCRITICAL_SECTION_); + + struct _SECURITY_ATTRIBUTES; # ifdef BOOST_NO_ANSI_APIS - __declspec(dllimport) void* __stdcall - CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*); - __declspec(dllimport) void* __stdcall - CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*); - __declspec(dllimport) void* __stdcall - CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*); - __declspec(dllimport) void* __stdcall - OpenEventW(unsigned long,int,wchar_t const*); + __declspec(dllimport) HANDLE_ WINAPI + CreateMutexW(_SECURITY_ATTRIBUTES*, BOOL_, LPCWSTR_); + __declspec(dllimport) HANDLE_ WINAPI + OpenMutexW(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCWSTR_ lpName); + __declspec(dllimport) HANDLE_ WINAPI + CreateSemaphoreW(_SECURITY_ATTRIBUTES*, LONG_, LONG_, LPCWSTR_); + __declspec(dllimport) HANDLE_ WINAPI + OpenSemaphoreW(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCWSTR_ lpName); + __declspec(dllimport) HANDLE_ WINAPI + CreateEventW(_SECURITY_ATTRIBUTES*, BOOL_, BOOL_, LPCWSTR_); + __declspec(dllimport) HANDLE_ WINAPI + OpenEventW(DWORD_, BOOL_, LPCWSTR_); # else - __declspec(dllimport) void* __stdcall - CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*); - __declspec(dllimport) void* __stdcall - CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*); - __declspec(dllimport) void* __stdcall - CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*); - __declspec(dllimport) void* __stdcall - OpenEventA(unsigned long,int,char const*); -# endif - __declspec(dllimport) int __stdcall - ReleaseMutex(void*); - __declspec(dllimport) unsigned long __stdcall - WaitForSingleObject(void*,unsigned long); - __declspec(dllimport) unsigned long __stdcall - WaitForMultipleObjects(unsigned long nCount, - void* const * lpHandles, - int bWaitAll, - unsigned long dwMilliseconds); - __declspec(dllimport) int __stdcall - ReleaseSemaphore(void*,long,long*); - typedef void (__stdcall *PAPCFUNC8)(ULONG_PTR_); - __declspec(dllimport) unsigned long __stdcall - QueueUserAPC(PAPCFUNC8,void*,ULONG_PTR_); -# ifndef UNDER_CE - __declspec(dllimport) int __stdcall - SetEvent(void*); - __declspec(dllimport) int __stdcall - ResetEvent(void*); -# else - using ::SetEvent; - using ::ResetEvent; + __declspec(dllimport) HANDLE_ WINAPI + CreateMutexA(_SECURITY_ATTRIBUTES*, BOOL_, LPCSTR_); + __declspec(dllimport) HANDLE_ WINAPI + OpenMutexA(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCSTR_ lpName); + __declspec(dllimport) HANDLE_ WINAPI + CreateSemaphoreA(_SECURITY_ATTRIBUTES*, LONG_, LONG_, LPCSTR_); + __declspec(dllimport) HANDLE_ WINAPI + OpenSemaphoreA(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCSTR_ lpName); + __declspec(dllimport) HANDLE_ WINAPI + CreateEventA(_SECURITY_ATTRIBUTES*, BOOL_, BOOL_, LPCSTR_); + __declspec(dllimport) HANDLE_ WINAPI + OpenEventA(DWORD_, BOOL_, LPCSTR_); # endif + __declspec(dllimport) BOOL_ WINAPI + ReleaseMutex(HANDLE_); + __declspec(dllimport) DWORD_ WINAPI + WaitForSingleObject(HANDLE_, DWORD_); + __declspec(dllimport) DWORD_ WINAPI + WaitForMultipleObjects(DWORD_ nCount, + HANDLE_ const * lpHandles, + BOOL_ bWaitAll, + DWORD_ dwMilliseconds); + __declspec(dllimport) BOOL_ WINAPI + ReleaseSemaphore(HANDLE_, LONG_, LONG_*); + __declspec(dllimport) BOOL_ WINAPI + SetEvent(HANDLE_); + __declspec(dllimport) BOOL_ WINAPI + ResetEvent(HANDLE_); + + typedef void (__stdcall *PAPCFUNC_)(ULONG_PTR_); + __declspec(dllimport) DWORD_ WINAPI + QueueUserAPC(PAPCFUNC_, HANDLE_, ULONG_PTR_); + +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + __declspec(dllimport) void WINAPI InitOnceInitialize(PINIT_ONCE_); + __declspec(dllimport) BOOL_ WINAPI InitOnceExecuteOnce(PINIT_ONCE_ InitOnce, PINIT_ONCE_FN_ InitFn, PVOID_ Parameter, LPVOID_* Context); + __declspec(dllimport) BOOL_ WINAPI InitOnceBeginInitialize(LPINIT_ONCE_ lpInitOnce, DWORD_ dwFlags, BOOL_* fPending, LPVOID_* lpContext); + __declspec(dllimport) BOOL_ WINAPI InitOnceComplete(LPINIT_ONCE_ lpInitOnce, DWORD_ dwFlags, LPVOID_* lpContext); + + + __declspec(dllimport) void WINAPI InitializeSRWLock(PSRWLOCK_ SRWLock); + __declspec(dllimport) void WINAPI AcquireSRWLockExclusive(PSRWLOCK_ SRWLock); + __declspec(dllimport) BOOLEAN_ WINAPI TryAcquireSRWLockExclusive(PSRWLOCK_ SRWLock); + __declspec(dllimport) void WINAPI ReleaseSRWLockExclusive(PSRWLOCK_ SRWLock); + __declspec(dllimport) void WINAPI AcquireSRWLockShared(PSRWLOCK_ SRWLock); + __declspec(dllimport) BOOLEAN_ WINAPI TryAcquireSRWLockShared(PSRWLOCK_ SRWLock); + __declspec(dllimport) void WINAPI ReleaseSRWLockShared(PSRWLOCK_ SRWLock); + + __declspec(dllimport) void WINAPI InitializeConditionVariable(PCONDITION_VARIABLE_ ConditionVariable); + __declspec(dllimport) void WINAPI WakeConditionVariable(PCONDITION_VARIABLE_ ConditionVariable); + __declspec(dllimport) void WINAPI WakeAllConditionVariable(PCONDITION_VARIABLE_ ConditionVariable); + __declspec(dllimport) BOOL_ WINAPI SleepConditionVariableCS(PCONDITION_VARIABLE_ ConditionVariable, PCRITICAL_SECTION_ CriticalSection, DWORD_ dwMilliseconds); + __declspec(dllimport) BOOL_ WINAPI SleepConditionVariableSRW(PCONDITION_VARIABLE_ ConditionVariable, PSRWLOCK_ SRWLock, DWORD_ dwMilliseconds, ULONG_ Flags); +#endif } // extern "C" - const DWORD_ infinite = (DWORD_)0xFFFFFFFF; - const DWORD_ wait_abandoned = 0x00000080L; - const DWORD_ wait_object_0 = 0x00000000L; - const DWORD_ wait_timeout = 0x00000102L; - const DWORD_ wait_failed = (DWORD_)0xFFFFFFFF; +const DWORD_ infinite = (DWORD_)0xFFFFFFFF; +const DWORD_ wait_abandoned = 0x00000080L; +const DWORD_ wait_object_0 = 0x00000000L; +const DWORD_ wait_timeout = 0x00000102L; +const DWORD_ wait_failed = (DWORD_)0xFFFFFFFF; + +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 +const DWORD_ init_once_async = 0x00000002UL; +const DWORD_ init_once_check_only = 0x00000001UL; +const DWORD_ init_once_init_failed = 0x00000004UL; +const DWORD_ init_once_ctx_reserved_bits = 2; + +const ULONG_ condition_variable_lockmode_shared = 0x00000001; +#endif #endif // defined( BOOST_USE_WINDOWS_H ) +const DWORD_ max_non_infinite_wait = (DWORD_)0xFFFFFFFE; + +BOOST_FORCEINLINE HANDLE_ create_anonymous_mutex(_SECURITY_ATTRIBUTES* lpAttributes, BOOL_ bInitialOwner) +{ +#ifdef BOOST_NO_ANSI_APIS + return CreateMutexW(lpAttributes, bInitialOwner, 0); +#else + return CreateMutexA(lpAttributes, bInitialOwner, 0); +#endif +} + +BOOST_FORCEINLINE HANDLE_ create_anonymous_semaphore(_SECURITY_ATTRIBUTES* lpAttributes, LONG_ lInitialCount, LONG_ lMaximumCount) +{ +#ifdef BOOST_NO_ANSI_APIS + return CreateSemaphoreW(lpAttributes, lInitialCount, lMaximumCount, 0); +#else + return CreateSemaphoreA(lpAttributes, lInitialCount, lMaximumCount, 0); +#endif +} + +BOOST_FORCEINLINE HANDLE_ create_anonymous_event(_SECURITY_ATTRIBUTES* lpAttributes, BOOL_ bManualReset, BOOL_ bInitialState) +{ +#ifdef BOOST_NO_ANSI_APIS + return CreateEventW(lpAttributes, bManualReset, bInitialState, 0); +#else + return CreateEventA(lpAttributes, bManualReset, bInitialState, 0); +#endif +} + } } } diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/system.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/system.hpp index 35b6682eb..2c2d82a8a 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/system.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/system.hpp @@ -1,6 +1,7 @@ // system.hpp --------------------------------------------------------------// // Copyright 2010 Vicente J. Botet Escriba +// Copyright (c) Microsoft Corporation 2014 // Distributed under the Boost Software License, Version 1.0. // See http://www.boost.org/LICENSE_1_0.txt @@ -20,7 +21,11 @@ namespace detail { namespace winapi { #if defined( BOOST_USE_WINDOWS_H ) typedef ::SYSTEM_INFO SYSTEM_INFO_; - extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *); +# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_WINXP +extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *); +# else +extern "C" __declspec(dllimport) void __stdcall GetNativeSystemInfo (struct system_info *); +# endif #else extern "C" { typedef struct _SYSTEM_INFO { @@ -42,8 +47,13 @@ extern "C" { WORD_ wProcessorRevision; } SYSTEM_INFO_; +# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_WINXP __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *); +# else + __declspec(dllimport) void __stdcall + GetNativeSystemInfo (struct system_info *); +# endif } #endif } diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/thread.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/thread.hpp index 3c1be666e..ee0dac624 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/thread.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/thread.hpp @@ -26,21 +26,21 @@ namespace winapi using ::GetCurrentThreadId; using ::SleepEx; using ::Sleep; + using ::SwitchToThread; #else -extern "C" { +extern "C" { # ifndef UNDER_CE - __declspec(dllimport) unsigned long __stdcall - GetCurrentThreadId(void); - __declspec(dllimport) unsigned long __stdcall - SleepEx(unsigned long,int); - __declspec(dllimport) void __stdcall - Sleep(unsigned long); + __declspec(dllimport) DWORD_ WINAPI GetCurrentThreadId(void); + __declspec(dllimport) DWORD_ WINAPI SleepEx(DWORD_, BOOL_); + __declspec(dllimport) void WINAPI Sleep(DWORD_); + __declspec(dllimport) BOOL_ WINAPI SwitchToThread(void); #else using ::GetCurrentThreadId; using ::SleepEx; using ::Sleep; -#endif -} + using ::SwitchToThread; +#endif +} #endif } } diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/thread_pool.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/thread_pool.hpp new file mode 100644 index 000000000..57059dc1b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/detail/winapi/thread_pool.hpp @@ -0,0 +1,96 @@ +// thread_pool.hpp --------------------------------------------------------------// + +// Copyright 2013 Andrey Semashev + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WINAPI_THREAD_POOL_HPP +#define BOOST_DETAIL_WINAPI_THREAD_POOL_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN2K + +namespace boost +{ +namespace detail +{ +namespace winapi +{ +#if defined( BOOST_USE_WINDOWS_H ) + +typedef ::WAITORTIMERCALLBACKFUNC WAITORTIMERCALLBACKFUNC_; +typedef ::WAITORTIMERCALLBACK WAITORTIMERCALLBACK_; + +using ::RegisterWaitForSingleObject; +using ::UnregisterWait; +using ::UnregisterWaitEx; + +const ULONG_ wt_execute_default = WT_EXECUTEDEFAULT; +const ULONG_ wt_execute_in_io_thread = WT_EXECUTEINIOTHREAD; +const ULONG_ wt_execute_in_ui_thread = WT_EXECUTEINUITHREAD; +const ULONG_ wt_execute_in_wait_thread = WT_EXECUTEINWAITTHREAD; +const ULONG_ wt_execute_only_once = WT_EXECUTEONLYONCE; +const ULONG_ wt_execute_in_timer_thread = WT_EXECUTEINTIMERTHREAD; +const ULONG_ wt_execute_long_function = WT_EXECUTELONGFUNCTION; +const ULONG_ wt_execute_in_persistent_io_thread = WT_EXECUTEINPERSISTENTIOTHREAD; +const ULONG_ wt_execute_in_persistent_thread = WT_EXECUTEINPERSISTENTTHREAD; +const ULONG_ wt_transfer_impersonation = WT_TRANSFER_IMPERSONATION; + +inline ULONG_ wt_set_max_threadpool_threads(ULONG_ flags, ULONG_ limit) +{ + return WT_SET_MAX_THREADPOOL_THREADS(flags, limit); +} + +#else + +extern "C" { + +typedef void (NTAPI* WAITORTIMERCALLBACKFUNC_) (PVOID_, BOOLEAN_); +typedef WAITORTIMERCALLBACKFUNC_ WAITORTIMERCALLBACK_; + +__declspec(dllimport) BOOL_ WINAPI RegisterWaitForSingleObject +( + HANDLE_* phNewWaitObject, + HANDLE_ hObject, + WAITORTIMERCALLBACK_ Callback, + PVOID_ Context, + ULONG_ dwMilliseconds, + ULONG_ dwFlags +); + +__declspec(dllimport) BOOL_ WINAPI UnregisterWait(HANDLE_ WaitHandle); +__declspec(dllimport) BOOL_ WINAPI UnregisterWaitEx(HANDLE_ WaitHandle, HANDLE_ CompletionEvent); + +} // extern "C" + +const ULONG_ wt_execute_default = 0x00000000; +const ULONG_ wt_execute_in_io_thread = 0x00000001; +const ULONG_ wt_execute_in_ui_thread = 0x00000002; +const ULONG_ wt_execute_in_wait_thread = 0x00000004; +const ULONG_ wt_execute_only_once = 0x00000008; +const ULONG_ wt_execute_in_timer_thread = 0x00000020; +const ULONG_ wt_execute_long_function = 0x00000010; +const ULONG_ wt_execute_in_persistent_io_thread = 0x00000040; +const ULONG_ wt_execute_in_persistent_thread = 0x00000080; +const ULONG_ wt_transfer_impersonation = 0x00000100; + +inline ULONG_ wt_set_max_threadpool_threads(ULONG_ flags, ULONG_ limit) +{ + return flags | (limit << 16); +} + +#endif +} +} +} + +#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN2K + +#endif // BOOST_DETAIL_WINAPI_THREAD_POOL_HPP diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/time.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/time.hpp index b3e4c4416..6a6b44711 100644 --- a/src/thirdparty/boost_lib/boost/detail/winapi/time.hpp +++ b/src/thirdparty/boost_lib/boost/detail/winapi/time.hpp @@ -1,6 +1,7 @@ // time.hpp --------------------------------------------------------------// // Copyright 2010 Vicente J. Botet Escriba +// Copyright (c) Microsoft Corporation 2014 // Distributed under the Boost Software License, Version 1.0. // See http://www.boost.org/LICENSE_1_0.txt @@ -10,6 +11,7 @@ #define BOOST_DETAIL_WINAPI_TIME_HPP #include +#include #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once @@ -18,7 +20,9 @@ namespace boost { namespace detail { namespace winapi { + #if defined( BOOST_USE_WINDOWS_H ) + typedef FILETIME FILETIME_; typedef PFILETIME PFILETIME_; typedef LPFILETIME LPFILETIME_; @@ -29,12 +33,21 @@ namespace winapi { #ifdef BOOST_HAS_GETSYSTEMTIMEASFILETIME // Windows CE does not define GetSystemTimeAsFileTime using ::GetSystemTimeAsFileTime; #endif + #if BOOST_PLAT_WINDOWS_DESKTOP using ::FileTimeToLocalFileTime; + #endif using ::GetSystemTime; using ::SystemTimeToFileTime; + + #if BOOST_PLAT_WINDOWS_DESKTOP using ::GetTickCount; + #endif + #if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + using ::GetTickCount64; + #endif #else + extern "C" { typedef struct _FILETIME { DWORD_ dwLowDateTime; @@ -64,9 +77,16 @@ extern "C" { __declspec(dllimport) int WINAPI SystemTimeToFileTime(const SYSTEMTIME_* lpSystemTime, FILETIME_* lpFileTime); + #if BOOST_PLAT_WINDOWS_DESKTOP __declspec(dllimport) DWORD_ WINAPI GetTickCount(); + #endif + #if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6 + __declspec(dllimport) ULONGLONG_ WINAPI + GetTickCount64(); + #endif } + #endif #ifndef BOOST_HAS_GETSYSTEMTIMEASFILETIME diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/tls.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/tls.hpp new file mode 100644 index 000000000..d948693cc --- /dev/null +++ b/src/thirdparty/boost_lib/boost/detail/winapi/tls.hpp @@ -0,0 +1,49 @@ +// tls.hpp --------------------------------------------------------------// + +// Copyright 2013 Andrey Semashev + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WINAPI_TLS_HPP +#define BOOST_DETAIL_WINAPI_TLS_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost +{ +namespace detail +{ +namespace winapi +{ +#if defined( BOOST_USE_WINDOWS_H ) + +using ::TlsAlloc; +using ::TlsGetValue; +using ::TlsSetValue; +using ::TlsFree; + +const DWORD_ tls_out_of_indexes = TLS_OUT_OF_INDEXES; + +#else + +extern "C" { +__declspec(dllimport) DWORD_ WINAPI TlsAlloc(void); +__declspec(dllimport) LPVOID_ WINAPI TlsGetValue(DWORD_ dwTlsIndex); +__declspec(dllimport) BOOL_ WINAPI TlsSetValue(DWORD_ dwTlsIndex, LPVOID_ lpTlsValue); +__declspec(dllimport) BOOL_ WINAPI TlsFree(DWORD_ dwTlsIndex); +} + +const DWORD_ tls_out_of_indexes = 0xFFFFFFFF; + +#endif +} +} +} + +#endif // BOOST_DETAIL_WINAPI_TLS_HPP diff --git a/src/thirdparty/boost_lib/boost/detail/winapi/waitable_timer.hpp b/src/thirdparty/boost_lib/boost/detail/winapi/waitable_timer.hpp new file mode 100644 index 000000000..52a7338a2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/detail/winapi/waitable_timer.hpp @@ -0,0 +1,110 @@ +// waitable_timer.hpp --------------------------------------------------------------// + +// Copyright 2013 Andrey Semashev + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + + +#ifndef BOOST_DETAIL_WINAPI_WAITABLE_TIMER_HPP +#define BOOST_DETAIL_WINAPI_WAITABLE_TIMER_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost +{ +namespace detail +{ +namespace winapi +{ +#if defined( BOOST_USE_WINDOWS_H ) + +typedef ::PTIMERAPCROUTINE PTIMERAPCROUTINE_; + +# ifdef BOOST_NO_ANSI_APIS +using ::CreateWaitableTimerW; +using ::OpenWaitableTimerW; +# else +using ::CreateWaitableTimerA; +using ::OpenWaitableTimerA; +# endif +using ::SetWaitableTimer; +using ::CancelWaitableTimer; + +#else + +extern "C" { + +struct _SECURITY_ATTRIBUTES; + +typedef void (WINAPI* PTIMERAPCROUTINE_) +( + LPVOID_ lpArgToCompletionRoutine, + DWORD_ dwTimerLowValue, + DWORD_ dwTimerHighValue +); + +# ifdef BOOST_NO_ANSI_APIS +__declspec(dllimport) HANDLE_ WINAPI CreateWaitableTimerW +( + _SECURITY_ATTRIBUTES* lpTimerAttributes, + BOOL_ bManualReset, + LPCWSTR_ lpTimerName +); + +__declspec(dllimport) HANDLE_ WINAPI OpenWaitableTimerW +( + DWORD_ dwDesiredAccess, + BOOL_ bInheritHandle, + LPCWSTR_ lpTimerName +); +# else +__declspec(dllimport) HANDLE_ WINAPI CreateWaitableTimerA +( + _SECURITY_ATTRIBUTES* lpTimerAttributes, + BOOL_ bManualReset, + LPCSTR_ lpTimerName +); + +__declspec(dllimport) HANDLE_ WINAPI OpenWaitableTimerA +( + DWORD_ dwDesiredAccess, + BOOL_ bInheritHandle, + LPCSTR_ lpTimerName +); +# endif + +__declspec(dllimport) BOOL_ WINAPI SetWaitableTimer +( + HANDLE_ hTimer, + const LARGE_INTEGER_ *lpDueTime, + LONG_ lPeriod, + PTIMERAPCROUTINE_ pfnCompletionRoutine, + LPVOID_ lpArgToCompletionRoutine, + BOOL_ fResume +); + +__declspec(dllimport) BOOL_ WINAPI CancelWaitableTimer(HANDLE_ hTimer); + +} + +#endif + +BOOST_FORCEINLINE HANDLE_ create_anonymous_waitable_timer(_SECURITY_ATTRIBUTES* lpTimerAttributes, BOOL_ bManualReset) +{ +#ifdef BOOST_NO_ANSI_APIS + return CreateWaitableTimerW(lpTimerAttributes, bManualReset, 0); +#else + return CreateWaitableTimerA(lpTimerAttributes, bManualReset, 0); +#endif +} + +} +} +} + +#endif // BOOST_DETAIL_WINAPI_WAITABLE_TIMER_HPP diff --git a/src/thirdparty/boost_lib/boost/exception.hpp b/src/thirdparty/boost_lib/boost/exception.hpp deleted file mode 100644 index 6424159c6..000000000 --- a/src/thirdparty/boost_lib/boost/exception.hpp +++ /dev/null @@ -1,11 +0,0 @@ -//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc. - -//Distributed under the Boost Software License, Version 1.0. (See accompanying -//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -#ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492 -#define UUID_1D94A7C6054E11DB9804B622A1EF5492 - -#error The header has been deprecated. Please #include instead. - -#endif diff --git a/src/thirdparty/boost_lib/boost/exception/N3757.hpp b/src/thirdparty/boost_lib/boost/exception/N3757.hpp new file mode 100644 index 000000000..23b06066b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/exception/N3757.hpp @@ -0,0 +1,46 @@ +//Copyright (c) 2006-2013 Emil Dotchevski and Reverge Studios, Inc. + +//Distributed under the Boost Software License, Version 1.0. (See accompanying +//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef UUID_9011016A11A711E3B46CD9FA6088709B +#define UUID_9011016A11A711E3B46CD9FA6088709B +#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include +#include + +namespace +boost + { + //Here we're using the boost::error_info machinery to store the info in the exception + //object. Within the context of N3757, this is strictly an implementation detail. + + template + inline + void + exception:: + set( typename Tag::type const & v ) + { + exception_detail::set_info(*this,error_info(v)); + } + + template + inline + typename Tag::type const * + exception:: + get() const + { + return get_error_info >(*this); + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/src/thirdparty/boost_lib/boost/exception/detail/attribute_noreturn.hpp b/src/thirdparty/boost_lib/boost/exception/detail/attribute_noreturn.hpp deleted file mode 100644 index ae9f031ef..000000000 --- a/src/thirdparty/boost_lib/boost/exception/detail/attribute_noreturn.hpp +++ /dev/null @@ -1,17 +0,0 @@ -//Copyright (c) 2009 Emil Dotchevski and Reverge Studios, Inc. - -//Distributed under the Boost Software License, Version 1.0. (See accompanying -//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -#ifndef UUID_61531AB0680611DEADD5846855D89593 -#define UUID_61531AB0680611DEADD5846855D89593 - -#if defined(_MSC_VER) -#define BOOST_ATTRIBUTE_NORETURN __declspec(noreturn) -#elif defined(__GNUC__) -#define BOOST_ATTRIBUTE_NORETURN __attribute__((__noreturn__)) -#else -#define BOOST_ATTRIBUTE_NORETURN -#endif - -#endif diff --git a/src/thirdparty/boost_lib/boost/exception/detail/exception_ptr.hpp b/src/thirdparty/boost_lib/boost/exception/detail/exception_ptr.hpp index 36298fa4b..530a6bd62 100644 --- a/src/thirdparty/boost_lib/boost/exception/detail/exception_ptr.hpp +++ b/src/thirdparty/boost_lib/boost/exception/detail/exception_ptr.hpp @@ -34,7 +34,7 @@ namespace boost { class exception_ptr; - BOOST_ATTRIBUTE_NORETURN void rethrow_exception( exception_ptr const & ); + BOOST_NORETURN void rethrow_exception( exception_ptr const & ); exception_ptr current_exception(); class @@ -454,7 +454,7 @@ boost return ret; } - BOOST_ATTRIBUTE_NORETURN + BOOST_NORETURN inline void rethrow_exception( exception_ptr const & p ) diff --git a/src/thirdparty/boost_lib/boost/exception/exception.hpp b/src/thirdparty/boost_lib/boost/exception/exception.hpp index 31d43178d..d762cf827 100644 --- a/src/thirdparty/boost_lib/boost/exception/exception.hpp +++ b/src/thirdparty/boost_lib/boost/exception/exception.hpp @@ -207,6 +207,12 @@ boost class exception { + // + public: + template void set( typename Tag::type const & ); + template typename Tag::type const * get() const; + // + protected: exception(): diff --git a/src/thirdparty/boost_lib/boost/flyweight.hpp b/src/thirdparty/boost_lib/boost/flyweight.hpp index 6fe304268..852ea8ecf 100644 --- a/src/thirdparty/boost_lib/boost/flyweight.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_HPP #define BOOST_FLYWEIGHT_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory.hpp b/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory.hpp index bb5ae7654..96deee3ee 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2009 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_ASSOC_CONTAINER_FACTORY_HPP #define BOOST_FLYWEIGHT_ASSOC_CONTAINER_FACTORY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -22,6 +22,10 @@ #include #include +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#endif + namespace boost{namespace flyweights{namespace detail{ BOOST_FLYWEIGHT_NESTED_XXX_IF_NOT_PLACEHOLDER_EXPRESSION_DEF(iterator); BOOST_FLYWEIGHT_NESTED_XXX_IF_NOT_PLACEHOLDER_EXPRESSION_DEF(value_type); @@ -57,6 +61,13 @@ class assoc_container_factory_class:public factory_marker return cont.insert(x).first; } +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + handle_type insert(entry_type&& x) + { + return cont.insert(std::move(x)).first; + } +#endif + void erase(handle_type h) { cont.erase(h); diff --git a/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory_fwd.hpp index 2d0c356d7..278c04d71 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/assoc_container_factory_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_ASSOC_CONTAINER_FACTORY_FWD_HPP #define BOOST_FLYWEIGHT_ASSOC_CONTAINER_FACTORY_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/default_value_policy.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/default_value_policy.hpp index 186e1e0d8..4209a69c1 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/default_value_policy.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/default_value_policy.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2008 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -9,12 +9,14 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_DEFAULT_VALUE_POLICY_HPP #define BOOST_FLYWEIGHT_DETAIL_DEFAULT_VALUE_POLICY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif +#include /* keep it first to prevent nasty warns in MSVC */ +#include +#include #include -#include /* Default value policy: the key is the same as the value. */ @@ -35,10 +37,31 @@ struct default_value_policy:value_marker { /* template ctors */ -#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit rep_type -#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \ - :x(BOOST_PP_ENUM_PARAMS(n,t)){} -#include +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)&&\ + !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)&&\ + BOOST_WORKAROUND(__GNUC__,<=4)&&(__GNUC__<4||__GNUC_MINOR__<=4) + +/* GCC 4.4.2 (and probably prior) bug: the default ctor generated by the + * variadic temmplate ctor below fails to value-initialize x. + */ + + rep_type():x(){} +#endif + +#define BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY(args) \ + :x(BOOST_FLYWEIGHT_FORWARD(args)){} + + BOOST_FLYWEIGHT_PERFECT_FWD( + explicit rep_type, + BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY) + +#undef BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY + + rep_type(const rep_type& r):x(r.x){} + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + rep_type(rep_type&& r):x(std::move(r.x)){} +#endif operator const value_type&()const{return x;} @@ -47,6 +70,10 @@ struct default_value_policy:value_marker static void construct_value(const rep_type&){} static void copy_value(const rep_type&){} + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + static void move_value(const rep_type&){} +#endif }; } /* namespace flyweights::detail */ diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/dyn_perfect_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/dyn_perfect_fwd.hpp index e921718a4..28b0c42c8 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/dyn_perfect_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/dyn_perfect_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2008 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -6,7 +6,46 @@ * See http://www.boost.org/libs/flyweight for library home page. */ -/* no include guards */ +#ifndef BOOST_FLYWEIGHT_DETAIL_DYN_PERFECT_FWD_HPP +#define BOOST_FLYWEIGHT_DETAIL_DYN_PERFECT_FWD_HPP + +#if defined(_MSC_VER) +#pragma once +#endif + +#include + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +#include +#include +#include +#include +#include +#include + +#define BOOST_FLYWEIGHT_PERFECT_FWD_ARG(z,n,_) \ +BOOST_PP_CAT(T,n)&& BOOST_PP_CAT(t,n) + +#define BOOST_FLYWEIGHT_PERFECT_FWD_N_AUX(n,name,body) \ +template \ +name(BOOST_PP_ENUM(n,BOOST_FLYWEIGHT_PERFECT_FWD_ARG,~)) \ +body((FORWARD)(n)) + +#define BOOST_FLYWEIGHT_PERFECT_FWD_N(z,n,data) \ +BOOST_FLYWEIGHT_PERFECT_FWD_N_AUX( \ + n,BOOST_PP_SEQ_HEAD(data), \ + BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(data))) + +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +name()body((ENUM)(0)) \ +BOOST_PP_REPEAT_FROM_TO( \ + 1,BOOST_PP_ADD(BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS,1), \ + BOOST_FLYWEIGHT_PERFECT_FWD_N,(name)(body)) + +#else + +/* no rvalue refs -> [const] Tn& overloads */ #include #include @@ -16,6 +55,7 @@ #include #include #include +#include #include #define BOOST_FLYWEIGHT_CONST(b) BOOST_PP_CAT(BOOST_FLYWEIGHT_CONST,b) @@ -34,42 +74,35 @@ BOOST_PP_CAT(T,n)& BOOST_PP_CAT(t,n) * marked const or not according to the given mask (a seq of 0 or 1) */ -#define BOOST_FLYWEIGHT_PERFECT_FWD(r,mask) \ +#define BOOST_FLYWEIGHT_PERFECT_FWD_MASK_AUX(r,name,body,mask) \ template \ -BOOST_FLYWEIGHT_PERFECT_FWD_NAME( \ +name( \ BOOST_PP_ENUM( \ BOOST_PP_SEQ_SIZE(mask),BOOST_FLYWEIGHT_PERFECT_FWD_ARG,mask)) \ -BOOST_FLYWEIGHT_PERFECT_FWD_BODY(BOOST_PP_SEQ_SIZE(mask)) +body((ENUM)(BOOST_PP_SEQ_SIZE(mask))) + +#define BOOST_FLYWEIGHT_PERFECT_FWD_MASK(r,data) \ +BOOST_FLYWEIGHT_PERFECT_FWD_MASK_AUX( \ + r, \ + BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_HEAD(data)), \ + BOOST_PP_SEQ_ELEM(1,BOOST_PP_SEQ_HEAD(data)), \ + BOOST_PP_SEQ_TAIL(data)) #define BOOST_FLYWEIGHT_01(z,n,_) ((0)(1)) /* Perfect forwarding overloads accepting 1 to n args */ -#define BOOST_FLYWEIGHT_PERFECT_FWDS_N(z,n,_) \ +#define BOOST_FLYWEIGHT_PERFECT_FWD_N(z,n,data) \ BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ - BOOST_FLYWEIGHT_PERFECT_FWD, \ + BOOST_FLYWEIGHT_PERFECT_FWD_MASK, \ + ((data)) \ BOOST_PP_REPEAT(n,BOOST_FLYWEIGHT_01,~)) -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS \ +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +name()body((ENUM)(0)) \ BOOST_PP_REPEAT_FROM_TO( \ 1,BOOST_PP_ADD(BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS,1), \ - BOOST_FLYWEIGHT_PERFECT_FWDS_N,~) - -/* generate the overloads */ - -BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS - -/* clean up */ - -#undef BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS -#undef BOOST_FLYWEIGHT_01 -#undef BOOST_FLYWEIGHT_PERFECT_FWD -#undef BOOST_FLYWEIGHT_PERFECT_FWD_ARG -#undef BOOST_FLYWEIGHT_CONST1 -#undef BOOST_FLYWEIGHT_CONST0 -#undef BOOST_FLYWEIGHT_CONST - -/* user supplied argument macros */ + BOOST_FLYWEIGHT_PERFECT_FWD_N,(name)(body)) -#undef BOOST_FLYWEIGHT_PERFECT_FWD_BODY -#undef BOOST_FLYWEIGHT_PERFECT_FWD_NAME +#endif +#endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/flyweight_core.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/flyweight_core.hpp index 41ae8320f..8be8586e1 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/flyweight_core.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/flyweight_core.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2013 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -9,15 +9,15 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_FLYWEIGHT_CORE_HPP #define BOOST_FLYWEIGHT_DETAIL_FLYWEIGHT_CORE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include #include +#include #include -#include #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400)) #pragma warning(push) @@ -66,6 +66,7 @@ struct flyweight_core_tracking_helper static void erase(const handle_type& h,Checker chk) { typedef typename core::lock_type lock_type; + core::init(); lock_type lock(core::mutex()); if(chk(h))core::factory().erase(h); } @@ -118,16 +119,25 @@ class flyweight_core /* insert overloads*/ -#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME static handle_type insert -#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \ -{ \ - return insert_rep(rep_type(BOOST_PP_ENUM_PARAMS(n,t))); \ +#define BOOST_FLYWEIGHT_PERFECT_FWD_INSERT_BODY(args) \ +{ \ + return insert_rep(rep_type(BOOST_FLYWEIGHT_FORWARD(args))); \ } -#include + + BOOST_FLYWEIGHT_PERFECT_FWD( + static handle_type insert, + BOOST_FLYWEIGHT_PERFECT_FWD_INSERT_BODY) + +#undef BOOST_FLYWEIGHT_PERFECT_FWD_INSERT_BODY static handle_type insert(const value_type& x){return insert_value(x);} static handle_type insert(value_type& x){return insert_value(x);} +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + static handle_type insert(const value_type&& x){return insert_value(x);} + static handle_type insert(value_type&& x){return insert_value(std::move(x));} +#endif + static const entry_type& entry(const base_handle_type& h) { return factory().entry(h); @@ -169,7 +179,12 @@ class flyweight_core init(); entry_type e(x); lock_type lock(mutex()); +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + base_handle_type h(factory().insert(std::move(e))); +#else base_handle_type h(factory().insert(e)); +#endif + BOOST_TRY{ ValuePolicy::construct_value( static_cast(entry(h))); @@ -187,7 +202,13 @@ class flyweight_core init(); entry_type e((rep_type(x))); lock_type lock(mutex()); + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + base_handle_type h(factory().insert(std::move(e))); +#else base_handle_type h(factory().insert(e)); +#endif + BOOST_TRY{ ValuePolicy::copy_value( static_cast(entry(h))); @@ -200,6 +221,45 @@ class flyweight_core return static_cast(h); } +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + static handle_type insert_rep(rep_type&& x) + { + init(); + entry_type e(std::move(x)); + lock_type lock(mutex()); + base_handle_type h(factory().insert(std::move(e))); + + BOOST_TRY{ + ValuePolicy::construct_value( + static_cast(entry(h))); + } + BOOST_CATCH(...){ + factory().erase(h); + BOOST_RETHROW; + } + BOOST_CATCH_END + return static_cast(h); + } + + static handle_type insert_value(value_type&& x) + { + init(); + entry_type e(rep_type(std::move(x))); + lock_type lock(mutex()); + base_handle_type h(factory().insert(std::move(e))); + BOOST_TRY{ + ValuePolicy::move_value( + static_cast(entry(h))); + } + BOOST_CATCH(...){ + factory().erase(h); + BOOST_RETHROW; + } + BOOST_CATCH_END + return static_cast(h); + } +#endif + static bool static_initializer; static factory_type* static_factory_ptr; static mutex_type* static_mutex_ptr; diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/is_placeholder_expr.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/is_placeholder_expr.hpp index a53e8d2db..a89aad650 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/is_placeholder_expr.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/is_placeholder_expr.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_IS_PLACEHOLDER_EXPR_HPP #define BOOST_FLYWEIGHT_DETAIL_IS_PLACEHOLDER_EXPR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/nested_xxx_if_not_ph.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/nested_xxx_if_not_ph.hpp index 8221efb77..32412b41a 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/nested_xxx_if_not_ph.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/nested_xxx_if_not_ph.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_NESTED_XXX_IF_NOT_PH_HPP #define BOOST_FLYWEIGHT_DETAIL_NESTED_XXX_IF_NOT_PH_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/not_placeholder_expr.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/not_placeholder_expr.hpp index a62bd0930..004c67035 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/not_placeholder_expr.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/not_placeholder_expr.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_NOT_PLACEHOLDER_EXPR_HPP #define BOOST_FLYWEIGHT_DETAIL_NOT_PLACEHOLDER_EXPR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/perfect_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/perfect_fwd.hpp index 05d670c69..1e0faa31c 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/perfect_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/perfect_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2008 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -6,23 +6,78 @@ * See http://www.boost.org/libs/flyweight for library home page. */ -/* Brute force implementation of perfect forwarding overloads. - * Usage: include after having defined the argument macros: - * BOOST_FLYWEIGHT_PERFECT_FWD_NAME - * BOOST_FLYWEIGHT_PERFECT_FWD_BODY - */ +#ifndef BOOST_FLYWEIGHT_DETAIL_PERFECT_FWD_HPP +#define BOOST_FLYWEIGHT_DETAIL_PERFECT_FWD_HPP + +#if defined(_MSC_VER) +#pragma once +#endif -/* This user_definable macro limits the maximum number of arguments to - * be perfect forwarded. Beware combinatorial explosion: manual perfect - * forwarding for n arguments produces 2^n distinct overloads. +/* C++03-compatible implementation of perfect forwarding. + * Usage: + * + * # define NAME ... + * # define BODY(args) {...BOOST_FLYWEIGHT_FORWARD(args)...} + * BOOST_FLYWEIGHT_PERFECT_FWD(name,body) + * + * where NAME includes the return type and qualifiers (if any) and BODY(args) + * is expected to fo the forwarding through BOOST_FLYWEIGHT_FORWARD(args). + * + * In compilers capable of perfect forwarding, the real thing is provided + * (just one variadic args overload is generated). Otherwise the machinery + * generates n+1 overloads, if rvalue refs are supported, or else 2^(n+1)-1 + * overloads accepting any combination of lvalue refs and const lvalue refs, + * up to BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS args. */ +#include /* keep it first to prevent nasty warns in MSVC */ +#include +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#endif + +#define BOOST_FLYWEIGHT_FORWARD_FORWARD_AUX(z,n,_) \ +std::forward(BOOST_PP_CAT(t,n)) + +#define BOOST_FLYWEIGHT_FORWARD_FORWARD(n) \ +BOOST_PP_ENUM(n,BOOST_FLYWEIGHT_FORWARD_FORWARD_AUX,~) + +#define BOOST_FLYWEIGHT_FORWARD_ENUM(n) BOOST_PP_ENUM_PARAMS(n,t) + +#define BOOST_FLYWEIGHT_FORWARD_PASS(arg) arg + +#define BOOST_FLYWEIGHT_FORWARD(args)\ +BOOST_PP_CAT(BOOST_FLYWEIGHT_FORWARD_,BOOST_PP_SEQ_HEAD(args))( \ +BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(args))) + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)||\ + defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + #if !defined(BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS) #define BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS 5 #endif +#if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS<0 +#error BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS must be >=0 +#endif + #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS<=5 #include #else #include #endif + +#else + +/* real perfect forwarding */ + +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +templatename(Args&&... args) \ +body((PASS)(std::forward(args)...)) + +#endif +#endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/pp_perfect_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/pp_perfect_fwd.hpp index 889d4c7e2..bf2ac5a01 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/pp_perfect_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/pp_perfect_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2008 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -6,148 +6,169 @@ * See http://www.boost.org/libs/flyweight for library home page. */ -/* no include guards */ +#ifndef BOOST_FLYWEIGHT_DETAIL_PP_PERFECT_FWD_HPP +#define BOOST_FLYWEIGHT_DETAIL_PP_PERFECT_FWD_HPP + +#if defined(_MSC_VER) +#pragma once +#endif + +#include + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +#define BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +name()body((FORWARD)(0)) #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=1 -#define BOOST_FLYWEIGHT_PERFECT_FWDS_1 \ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(1)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(1) +#define BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) \ +template name(T0&& t0)body((FORWARD)(1)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=2 -#define BOOST_FLYWEIGHT_PERFECT_FWDS_2 \ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(2)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(2)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(2)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(2) +#define BOOST_FLYWEIGHT_PERFECT_FWD_2(name,body) \ +template name(T0&& t0,T1&& t1)body((FORWARD)(2)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=3 -#define BOOST_FLYWEIGHT_PERFECT_FWDS_3 \ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(3) +#define BOOST_FLYWEIGHT_PERFECT_FWD_3(name,body) \ +template name(T0&& t0,T1&& t1,T2&& t2)body((FORWARD)(3)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=4 -#define BOOST_FLYWEIGHT_PERFECT_FWDS_4 \ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2,T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2,const T3& t3)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(4) +#define BOOST_FLYWEIGHT_PERFECT_FWD_4(name,body) \ +template name(T0&& t0,T1&& t1,T2&& t2,T3&& t3)body((FORWARD)(4)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=5 -#define BOOST_FLYWEIGHT_PERFECT_FWDS_5 \ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,T1& t1,const T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(T0& t0,const T1& t1,const T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,T1& t1,const T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2,T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2,T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2,const T3& t3,T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5)\ -template BOOST_FLYWEIGHT_PERFECT_FWD_NAME(const T0& t0,const T1& t1,const T2& t2,const T3& t3,const T4& t4)BOOST_FLYWEIGHT_PERFECT_FWD_BODY(5) -#endif - -#if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==0 -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS -#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==1 -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS \ -BOOST_FLYWEIGHT_PERFECT_FWDS_1 -#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==2 -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS \ -BOOST_FLYWEIGHT_PERFECT_FWDS_1 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_2 -#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==3 -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS \ -BOOST_FLYWEIGHT_PERFECT_FWDS_1 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_2 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_3 -#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==4 -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS \ -BOOST_FLYWEIGHT_PERFECT_FWDS_1 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_2 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_3 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_4 -#else /* BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==5 */ -#define BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS \ -BOOST_FLYWEIGHT_PERFECT_FWDS_1 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_2 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_3 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_4 \ -BOOST_FLYWEIGHT_PERFECT_FWDS_5 +#define BOOST_FLYWEIGHT_PERFECT_FWD_5(name,body) \ +template name(T0&& t0,T1&& t1,T2&& t2,T3&& t3,T4&& t4)body((FORWARD)(5)) #endif -/* generate the overloads */ - -BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS +#else -/* clean up */ +/* no rvalue refs -> [const] Tn& overloads */ -#undef BOOST_FLYWEIGHT_PERFECT_FWD_OVERLOADS +#define BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +name()body((ENUM)(0)) #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=1 -#undef BOOST_FLYWEIGHT_PERFECT_FWDS_1 +#define BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) \ +template name(T0& t0)body((ENUM)(1))\ +template name(const T0& t0)body((ENUM)(1)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=2 -#undef BOOST_FLYWEIGHT_PERFECT_FWDS_2 +#define BOOST_FLYWEIGHT_PERFECT_FWD_2(name,body) \ +template name(T0& t0,T1& t1)body((ENUM)(2))\ +template name(T0& t0,const T1& t1)body((ENUM)(2))\ +template name(const T0& t0,T1& t1)body((ENUM)(2))\ +template name(const T0& t0,const T1& t1)body((ENUM)(2)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=3 -#undef BOOST_FLYWEIGHT_PERFECT_FWDS_3 +#define BOOST_FLYWEIGHT_PERFECT_FWD_3(name,body) \ +template name(T0& t0,T1& t1,T2& t2)body((ENUM)(3))\ +template name(T0& t0,T1& t1,const T2& t2)body((ENUM)(3))\ +template name(T0& t0,const T1& t1,T2& t2)body((ENUM)(3))\ +template name(T0& t0,const T1& t1,const T2& t2)body((ENUM)(3))\ +template name(const T0& t0,T1& t1,T2& t2)body((ENUM)(3))\ +template name(const T0& t0,T1& t1,const T2& t2)body((ENUM)(3))\ +template name(const T0& t0,const T1& t1,T2& t2)body((ENUM)(3))\ +template name(const T0& t0,const T1& t1,const T2& t2)body((ENUM)(3)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=4 -#undef BOOST_FLYWEIGHT_PERFECT_FWDS_4 +#define BOOST_FLYWEIGHT_PERFECT_FWD_4(name,body) \ +template name(T0& t0,T1& t1,T2& t2,T3& t3)body((ENUM)(4))\ +template name(T0& t0,T1& t1,T2& t2,const T3& t3)body((ENUM)(4))\ +template name(T0& t0,T1& t1,const T2& t2,T3& t3)body((ENUM)(4))\ +template name(T0& t0,T1& t1,const T2& t2,const T3& t3)body((ENUM)(4))\ +template name(T0& t0,const T1& t1,T2& t2,T3& t3)body((ENUM)(4))\ +template name(T0& t0,const T1& t1,T2& t2,const T3& t3)body((ENUM)(4))\ +template name(T0& t0,const T1& t1,const T2& t2,T3& t3)body((ENUM)(4))\ +template name(T0& t0,const T1& t1,const T2& t2,const T3& t3)body((ENUM)(4))\ +template name(const T0& t0,T1& t1,T2& t2,T3& t3)body((ENUM)(4))\ +template name(const T0& t0,T1& t1,T2& t2,const T3& t3)body((ENUM)(4))\ +template name(const T0& t0,T1& t1,const T2& t2,T3& t3)body((ENUM)(4))\ +template name(const T0& t0,T1& t1,const T2& t2,const T3& t3)body((ENUM)(4))\ +template name(const T0& t0,const T1& t1,T2& t2,T3& t3)body((ENUM)(4))\ +template name(const T0& t0,const T1& t1,T2& t2,const T3& t3)body((ENUM)(4))\ +template name(const T0& t0,const T1& t1,const T2& t2,T3& t3)body((ENUM)(4))\ +template name(const T0& t0,const T1& t1,const T2& t2,const T3& t3)body((ENUM)(4)) #endif #if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS>=5 -#undef BOOST_FLYWEIGHT_PERFECT_FWDS_5 +#define BOOST_FLYWEIGHT_PERFECT_FWD_5(name,body) \ +template name(T0& t0,T1& t1,T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,const T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,const T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,const T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,T1& t1,const T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,const T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,const T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,const T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(T0& t0,const T1& t1,const T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,const T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,const T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,const T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,T1& t1,const T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,T2& t2,const T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,const T2& t2,T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,const T2& t2,T3& t3,const T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,const T2& t2,const T3& t3,T4& t4)body((ENUM)(5))\ +template name(const T0& t0,const T1& t1,const T2& t2,const T3& t3,const T4& t4)body((ENUM)(5)) +#endif + #endif -/* user supplied argument macros */ +#if BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==0 +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) +#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==1 +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) +#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==2 +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_2(name,body) +#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==3 +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_2(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_3(name,body) +#elif BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==4 +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_2(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_3(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_4(name,body) +#else /* BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS==5 */ +#define BOOST_FLYWEIGHT_PERFECT_FWD(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_0(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_1(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_2(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_3(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_4(name,body) \ +BOOST_FLYWEIGHT_PERFECT_FWD_5(name,body) +#endif -#undef BOOST_FLYWEIGHT_PERFECT_FWD_NAME -#undef BOOST_FLYWEIGHT_PERFECT_FWD_BODY +#endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/recursive_lw_mutex.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/recursive_lw_mutex.hpp index 2c33b2e02..6e780868e 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/recursive_lw_mutex.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/recursive_lw_mutex.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_RECURSIVE_LW_MUTEX_HPP #define BOOST_FLYWEIGHT_DETAIL_RECURSIVE_LW_MUTEX_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/detail/value_tag.hpp b/src/thirdparty/boost_lib/boost/flyweight/detail/value_tag.hpp index cf4b5723a..cec0d4997 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/detail/value_tag.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/detail/value_tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_DETAIL_VALUE_TAG_HPP #define BOOST_FLYWEIGHT_DETAIL_VALUE_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/factory_tag.hpp b/src/thirdparty/boost_lib/boost/flyweight/factory_tag.hpp index ddb747304..37b62556b 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/factory_tag.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/factory_tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_FACTORY_TAG_HPP #define BOOST_FLYWEIGHT_FACTORY_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/flyweight.hpp b/src/thirdparty/boost_lib/boost/flyweight/flyweight.hpp index b909b676f..624649b16 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/flyweight.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/flyweight.hpp @@ -1,6 +1,6 @@ /* Flyweight class. * - * Copyright 2006-2009 Joaquin M Lopez Munoz. + * Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -11,7 +11,7 @@ #ifndef BOOST_FLYWEIGHT_FLYWEIGHT_HPP #define BOOST_FLYWEIGHT_FLYWEIGHT_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include @@ -35,10 +36,15 @@ #include #include #include -#include #include #include +#if !defined(BOOST_NO_SFINAE)&&!defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) +#include +#include +#include +#endif + #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400)) #pragma warning(push) #pragma warning(disable:4521) /* multiple copy ctors */ @@ -182,20 +188,52 @@ class flyweight /* construct/copy/destroy */ - flyweight():h(core::insert(key_type())){} +#define BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY(args) \ + :h(core::insert(BOOST_FLYWEIGHT_FORWARD(args))){} + + BOOST_FLYWEIGHT_PERFECT_FWD( + explicit flyweight, + BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY) + +#undef BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY + +#if !defined(BOOST_NO_SFINAE)&&!defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + template + flyweight( + std::initializer_list list, + typename boost::enable_if< + boost::is_convertible,key_type> >::type* =0): + h(core::insert(list)){} +#endif + flyweight(const flyweight& x):h(x.h){} flyweight(flyweight& x):h(x.h){} - /* template ctors */ +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + flyweight(const flyweight&& x):h(x.h){} + flyweight(flyweight&& x):h(x.h){} +#endif -#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit flyweight -#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \ - :h(core::insert(BOOST_PP_ENUM_PARAMS(n,t))){} -#include +#if !defined(BOOST_NO_SFINAE)&&!defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + template + typename boost::enable_if< + boost::is_convertible,key_type>,flyweight&>::type + operator=(std::initializer_list list) + { + return operator=(flyweight(list)); + } +#endif flyweight& operator=(const flyweight& x){h=x.h;return *this;} flyweight& operator=(const value_type& x){return operator=(flyweight(x));} +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + flyweight& operator=(value_type&& x) + { + return operator=(flyweight(std::move(x))); + } +#endif + /* convertibility to underlying type */ const key_type& get_key()const{return core::key(h);} diff --git a/src/thirdparty/boost_lib/boost/flyweight/flyweight_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/flyweight_fwd.hpp index 6295a8dbf..31b06742a 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/flyweight_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/flyweight_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_FLYWEIGHT_FWD_HPP #define BOOST_FLYWEIGHT_FLYWEIGHT_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/hashed_factory.hpp b/src/thirdparty/boost_lib/boost/flyweight/hashed_factory.hpp index 18062aae8..899eb619e 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/hashed_factory.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/hashed_factory.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2009 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_HASHED_FACTORY_HPP #define BOOST_FLYWEIGHT_HASHED_FACTORY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -22,6 +22,10 @@ #include #include +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#endif + /* Flyweight factory based on a hashed container implemented * with Boost.MultiIndex. */ @@ -72,6 +76,13 @@ class hashed_factory_class:public factory_marker return &*cont.insert(x).first; } +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + handle_type insert(Entry&& x) + { + return &*cont.insert(std::move(x)).first; + } +#endif + void erase(handle_type h) { cont.erase(cont.iterator_to(*h)); diff --git a/src/thirdparty/boost_lib/boost/flyweight/hashed_factory_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/hashed_factory_fwd.hpp index 1da6b211e..a934118c6 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/hashed_factory_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/hashed_factory_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_HASHED_FACTORY_FWD_HPP #define BOOST_FLYWEIGHT_HASHED_FACTORY_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/holder_tag.hpp b/src/thirdparty/boost_lib/boost/flyweight/holder_tag.hpp index 745f1320f..43a01ff40 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/holder_tag.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/holder_tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_HOLDER_TAG_HPP #define BOOST_FLYWEIGHT_HOLDER_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder.hpp b/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder.hpp index d8d9cd3ae..a96bc5412 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_INTERMODULE_HOLDER_HPP #define BOOST_FLYWEIGHT_INTERMODULE_HOLDER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder_fwd.hpp index 8acc0ce77..f2ea8845d 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/intermodule_holder_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_INTERMODULE_HOLDER_FWD_HPP #define BOOST_FLYWEIGHT_INTERMODULE_HOLDER_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/key_value.hpp b/src/thirdparty/boost_lib/boost/flyweight/key_value.hpp index 5ac1c0d57..eb58d152c 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/key_value.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/key_value.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2008 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -9,14 +9,16 @@ #ifndef BOOST_FLYWEIGHT_KEY_VALUE_HPP #define BOOST_FLYWEIGHT_KEY_VALUE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif +#include /* keep it first to prevent nasty warns in MSVC */ +#include +#include #include #include #include -#include #include #include #include @@ -54,21 +56,34 @@ struct optimized_key_value:value_marker public: /* template ctors */ -#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit rep_type -#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \ - :value_ptr(0) \ -{ \ - new(spc_ptr())key_type(BOOST_PP_ENUM_PARAMS(n,t)); \ +#define BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY(args) \ + :value_ptr(0) \ +{ \ + new(spc_ptr())key_type(BOOST_FLYWEIGHT_FORWARD(args)); \ } -#include - rep_type(const value_type& x):value_ptr(&x){} + BOOST_FLYWEIGHT_PERFECT_FWD( + explicit rep_type, + BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY) + +#undef BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY rep_type(const rep_type& x):value_ptr(x.value_ptr) { if(!x.value_ptr)new(key_ptr())key_type(*x.key_ptr()); } + rep_type(const value_type& x):value_ptr(&x){} + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + rep_type(rep_type&& x):value_ptr(x.value_ptr) + { + if(!x.value_ptr)new(key_ptr())key_type(std::move(*x.key_ptr())); + } + + rep_type(value_type&& x):value_ptr(&x){} +#endif + ~rep_type() { if(!value_ptr) key_ptr()->~key_type(); @@ -113,7 +128,12 @@ struct optimized_key_value:value_marker if(!value_cted()){ /* value_ptr must be ==0, oherwise copy_value would have been called */ +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + key_type k(std::move(*key_ptr())); +#else key_type k(*key_ptr()); +#endif + key_ptr()->~key_type(); value_ptr= /* guarantees key won't be re-dted at ~rep_type if the */ static_cast(spc_ptr())+1; /* next statement throws */ @@ -126,6 +146,14 @@ struct optimized_key_value:value_marker if(!value_cted())value_ptr=new(spc_ptr())value_type(*value_ptr); } +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + void move_value()const + { + if(!value_cted())value_ptr= + new(spc_ptr())value_type(std::move(const_cast(*value_ptr))); + } +#endif + mutable typename boost::aligned_storage< (sizeof(key_type)>sizeof(value_type))? sizeof(key_type):sizeof(value_type), @@ -146,6 +174,13 @@ struct optimized_key_value:value_marker { r.copy_value(); } + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + static void move_value(const rep_type& r) + { + r.move_value(); + } +#endif }; template @@ -159,14 +194,33 @@ struct regular_key_value:value_marker public: /* template ctors */ -#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit rep_type -#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \ - :key(BOOST_PP_ENUM_PARAMS(n,t)),value_ptr(0){} -#include +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)&&\ + !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)&&\ + BOOST_WORKAROUND(__GNUC__,<=4)&&(__GNUC__<4||__GNUC_MINOR__<=4) - rep_type(const value_type& x):key(no_key_from_value_failure()){} +/* GCC 4.4.2 (and probably prior) bug: the default ctor generated by the + * variadic temmplate ctor below fails to value-initialize key. + */ + + rep_type():key(),value_ptr(0){} +#endif + +#define BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY(args) \ + :key(BOOST_FLYWEIGHT_FORWARD(args)),value_ptr(0){} + + BOOST_FLYWEIGHT_PERFECT_FWD( + explicit rep_type, + BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY) + +#undef BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY rep_type(const rep_type& x):key(x.key),value_ptr(0){} + rep_type(const value_type& x):key(no_key_from_value_failure()){} + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + rep_type(rep_type&& x):key(std::move(x.key)),value_ptr(0){} + rep_type(value_type&& x):key(no_key_from_value_failure()){} +#endif ~rep_type() { @@ -217,7 +271,16 @@ struct regular_key_value:value_marker r.construct_value(); } + /* copy_value() and move_value() can't really ever be called, provided to avoid + * compile errors (it is the no_key_from_value_failure compile error we want to + * appear in these cases). + */ + static void copy_value(const rep_type&){} + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + static void move_value(const rep_type&){} +#endif }; } /* namespace flyweights::detail */ diff --git a/src/thirdparty/boost_lib/boost/flyweight/key_value_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/key_value_fwd.hpp index d20d71e1c..878a778c0 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/key_value_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/key_value_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_KEY_VALUE_FWD_HPP #define BOOST_FLYWEIGHT_KEY_VALUE_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/locking_tag.hpp b/src/thirdparty/boost_lib/boost/flyweight/locking_tag.hpp index c467a4acc..d32343679 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/locking_tag.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/locking_tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_LOCKING_TAG_HPP #define BOOST_FLYWEIGHT_LOCKING_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/no_locking.hpp b/src/thirdparty/boost_lib/boost/flyweight/no_locking.hpp index fa0031a04..4d1bcd8bf 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/no_locking.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/no_locking.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_NO_LOCKING_HPP #define BOOST_FLYWEIGHT_NO_LOCKING_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/no_locking_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/no_locking_fwd.hpp index 95177e986..132f50dc8 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/no_locking_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/no_locking_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_NO_LOCKING_FWD_HPP #define BOOST_FLYWEIGHT_NO_LOCKING_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/no_tracking.hpp b/src/thirdparty/boost_lib/boost/flyweight/no_tracking.hpp index 1433d6dac..47ce8f9ef 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/no_tracking.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/no_tracking.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_NO_TRACKING_HPP #define BOOST_FLYWEIGHT_NO_TRACKING_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/no_tracking_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/no_tracking_fwd.hpp index dd6b446e3..a60101253 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/no_tracking_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/no_tracking_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_NO_TRACKING_FWD_HPP #define BOOST_FLYWEIGHT_NO_TRACKING_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/refcounted.hpp b/src/thirdparty/boost_lib/boost/flyweight/refcounted.hpp index dd0b925c8..7b5541637 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/refcounted.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/refcounted.hpp @@ -1,4 +1,4 @@ -/* Copyright 2006-2013 Joaquin M Lopez Munoz. +/* Copyright 2006-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_REFCOUNTED_HPP #define BOOST_FLYWEIGHT_REFCOUNTED_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -21,6 +21,10 @@ #include #include +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#endif + /* Refcounting tracking policy. * The implementation deserves some explanation; values are equipped with two * reference counts: @@ -63,6 +67,22 @@ class refcounted_value x=r.x; return *this; } + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + explicit refcounted_value(Value&& x_): + x(std::move(x_)),ref(0),del_ref(0) + {} + + refcounted_value(refcounted_value&& r): + x(std::move(r.x)),ref(0),del_ref(0) + {} + + refcounted_value& operator=(refcounted_value&& r) + { + x=std::move(r.x); + return *this; + } +#endif operator const Value&()const{return x;} operator const Key&()const{return x;} diff --git a/src/thirdparty/boost_lib/boost/flyweight/refcounted_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/refcounted_fwd.hpp index cb0e72701..7da6f6ec2 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/refcounted_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/refcounted_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_REFCOUNTED_FWD_HPP #define BOOST_FLYWEIGHT_REFCOUNTED_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/set_factory.hpp b/src/thirdparty/boost_lib/boost/flyweight/set_factory.hpp index 42da89586..b0eeee75c 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/set_factory.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/set_factory.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_SET_FACTORY_HPP #define BOOST_FLYWEIGHT_SET_FACTORY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/set_factory_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/set_factory_fwd.hpp index 07cd0eae6..8d26e73de 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/set_factory_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/set_factory_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_SET_FACTORY_FWD_HPP #define BOOST_FLYWEIGHT_SET_FACTORY_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/simple_locking.hpp b/src/thirdparty/boost_lib/boost/flyweight/simple_locking.hpp index 503413320..23e7f3b8e 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/simple_locking.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/simple_locking.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_SIMPLE_LOCKING_HPP #define BOOST_FLYWEIGHT_SIMPLE_LOCKING_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/simple_locking_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/simple_locking_fwd.hpp index c81086058..a7212fb68 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/simple_locking_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/simple_locking_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_SIMPLE_LOCKING_FWD_HPP #define BOOST_FLYWEIGHT_SIMPLE_LOCKING_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/static_holder.hpp b/src/thirdparty/boost_lib/boost/flyweight/static_holder.hpp index 892bd1bf8..6cc1f51bc 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/static_holder.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/static_holder.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_STATIC_HOLDER_HPP #define BOOST_FLYWEIGHT_STATIC_HOLDER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/static_holder_fwd.hpp b/src/thirdparty/boost_lib/boost/flyweight/static_holder_fwd.hpp index 5f6f437e5..3624900dd 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/static_holder_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/static_holder_fwd.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_STATIC_HOLDER_FWD_HPP #define BOOST_FLYWEIGHT_STATIC_HOLDER_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/tag.hpp b/src/thirdparty/boost_lib/boost/flyweight/tag.hpp index 62efc36a1..52595541e 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/tag.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_TAG_HPP #define BOOST_FLYWEIGHT_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/flyweight/tracking_tag.hpp b/src/thirdparty/boost_lib/boost/flyweight/tracking_tag.hpp index efc7bce7a..cda8d05df 100644 --- a/src/thirdparty/boost_lib/boost/flyweight/tracking_tag.hpp +++ b/src/thirdparty/boost_lib/boost/flyweight/tracking_tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_FLYWEIGHT_TRACKING_TAG_HPP #define BOOST_FLYWEIGHT_TRACKING_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/foreach.hpp b/src/thirdparty/boost_lib/boost/foreach.hpp index 33b59202d..ac2e6134d 100644 --- a/src/thirdparty/boost_lib/boost/foreach.hpp +++ b/src/thirdparty/boost_lib/boost/foreach.hpp @@ -20,7 +20,7 @@ #ifndef BOOST_FOREACH // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -32,7 +32,7 @@ // Some compilers let us detect even const-qualified rvalues at compile-time #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) \ - || BOOST_WORKAROUND(BOOST_MSVC, >= 1310) && !defined(_PREFAST_) \ + || defined(BOOST_MSVC) && !defined(_PREFAST_) \ || (BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 5) && !defined(BOOST_INTEL) && \ !defined(BOOST_CLANG)) \ || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL) && \ @@ -42,8 +42,7 @@ // Some compilers allow temporaries to be bound to non-const references. // These compilers make it impossible to for BOOST_FOREACH to detect // temporaries and avoid reevaluation of the collection expression. -# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ - || BOOST_WORKAROUND(__BORLANDC__, < 0x593) \ +# if BOOST_WORKAROUND(__BORLANDC__, < 0x593) \ || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ || BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) \ || BOOST_WORKAROUND(__DECCXX_VER, <= 60590042) @@ -55,8 +54,6 @@ || defined(BOOST_NO_SFINAE) \ || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(1400)) \ - || BOOST_WORKAROUND(__GNUC__, < 3) \ - || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 2)) \ || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__)) \ || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \ || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) \ @@ -349,9 +346,7 @@ struct foreach_iterator // // To treat the container as an array, use boost::as_array() in , // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... - #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 BOOST_MPL_ASSERT_MSG( (!is_char_array::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); - #endif // If the type is a pointer to a null terminated string (as opposed // to an array type), there is no ambiguity. @@ -380,9 +375,7 @@ struct foreach_reverse_iterator // // To treat the container as an array, use boost::as_array() in , // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... - #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 BOOST_MPL_ASSERT_MSG( (!is_char_array::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); - #endif // If the type is a pointer to a null terminated string (as opposed // to an array type), there is no ambiguity. diff --git a/src/thirdparty/boost_lib/boost/functional.hpp b/src/thirdparty/boost_lib/boost/functional.hpp index 3e0588e00..b618485c1 100644 --- a/src/thirdparty/boost_lib/boost/functional.hpp +++ b/src/thirdparty/boost_lib/boost/functional.hpp @@ -6,7 +6,7 @@ // Boost functional.hpp header file // See http://www.boost.org/libs/functional for documentation. // ------------------------------------------------------------------------------ -// $Id: functional.hpp 36246 2006-12-02 14:17:26Z andreas_huber69 $ +// $Id$ // ------------------------------------------------------------------------------ #ifndef BOOST_FUNCTIONAL_HPP diff --git a/src/thirdparty/boost_lib/boost/functional/hash/detail/float_functions.hpp b/src/thirdparty/boost_lib/boost/functional/hash/detail/float_functions.hpp index 4b8374d47..f3db52f9c 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash/detail/float_functions.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash/detail/float_functions.hpp @@ -7,12 +7,12 @@ #define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP #include -#include - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once #endif +#include + // Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have // sufficiently good floating point support to not require any // workarounds. diff --git a/src/thirdparty/boost_lib/boost/functional/hash/detail/hash_float.hpp b/src/thirdparty/boost_lib/boost/functional/hash/detail/hash_float.hpp index 7c3de31ae..ee0ee8774 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash/detail/hash_float.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash/detail/hash_float.hpp @@ -6,11 +6,11 @@ #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER) #define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once #endif -#include #include #include #include diff --git a/src/thirdparty/boost_lib/boost/functional/hash/detail/limits.hpp b/src/thirdparty/boost_lib/boost/functional/hash/detail/limits.hpp index f5b520ea9..4a971a6ac 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash/detail/limits.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash/detail/limits.hpp @@ -9,8 +9,9 @@ #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER) #define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once #endif #include diff --git a/src/thirdparty/boost_lib/boost/functional/hash/extensions.hpp b/src/thirdparty/boost_lib/boost/functional/hash/extensions.hpp index 998c08e46..eafaefe85 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash/extensions.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash/extensions.hpp @@ -13,6 +13,11 @@ #if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP) #define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#endif + #include #include #include @@ -32,18 +37,10 @@ # include #endif -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) #include #endif -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -#include -#endif - namespace boost { template @@ -232,11 +229,7 @@ namespace boost template struct inner { -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) static std::size_t call(Array const& v) -#else - static std::size_t call(Array& v) -#endif { const int size = sizeof(v) / sizeof(*v); return boost::hash_range(v, v + size); @@ -298,8 +291,6 @@ namespace boost template struct hash_impl; -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <> struct hash_impl { @@ -320,58 +311,6 @@ namespace boost #endif }; }; - -#else // Visual C++ 6.5 - - // Visual C++ 6.5 has problems with nested member functions and - // applying const to const types in templates. So we get this: - - template - struct hash_impl_msvc - { - template - struct inner - : public std::unary_function - { - std::size_t operator()(T const& val) const - { - return hash_detail::call_hash::call(val); - } - - std::size_t operator()(T& val) const - { - return hash_detail::call_hash::call(val); - } - }; - }; - - template <> - struct hash_impl_msvc - { - template - struct inner - : public std::unary_function - { - std::size_t operator()(T& val) const - { - return hash_detail::call_hash::call(val); - } - }; - }; - - template - struct hash_impl_msvc2 - : public hash_impl_msvc::value> - ::BOOST_NESTED_TEMPLATE inner {}; - - template <> - struct hash_impl - { - template - struct inner : public hash_impl_msvc2 {}; - }; - -#endif // Visual C++ 6.5 } #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } diff --git a/src/thirdparty/boost_lib/boost/functional/hash/hash.hpp b/src/thirdparty/boost_lib/boost/functional/hash/hash.hpp index 0adf9c901..3e5ab5bcf 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash/hash.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash/hash.hpp @@ -1,11 +1,17 @@ -// Copyright 2005-2009 Daniel James. +// Copyright 2005-2014 Daniel James. // 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) // Based on Peter Dimov's proposal // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf // issue 6.18. +// +// This also contains public domain code from MurmurHash. From the +// MurmurHash header: + +// MurmurHash3 was written by Austin Appleby, and is placed in the public +// domain. The author hereby disclaims copyright to this source code. #if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP) #define BOOST_FUNCTIONAL_HASH_HASH_HPP @@ -18,6 +24,7 @@ #include #include #include +#include #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) #include @@ -29,11 +36,15 @@ #if defined(BOOST_MSVC) #pragma warning(push) + +#if BOOST_MSVC >= 1400 #pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values // are always of range '0' to '4294967295'. // Loop executes infinitely. #endif +#endif + #if BOOST_WORKAROUND(__GNUC__, < 3) \ && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) #define BOOST_HASH_CHAR_TRAITS string_char_traits @@ -41,6 +52,12 @@ #define BOOST_HASH_CHAR_TRAITS char_traits #endif +#if defined(_MSC_VER) +# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r) +#else +# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r)) +#endif + namespace boost { namespace hash_detail @@ -188,6 +205,51 @@ namespace boost return seed; } + + template + inline void hash_combine_impl(SizeT& seed, SizeT value) + { + seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2); + } + + template + inline void hash_combine_impl(boost::uint32_t& h1, + boost::uint32_t k1) + { + const uint32_t c1 = 0xcc9e2d51; + const uint32_t c2 = 0x1b873593; + + k1 *= c1; + k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15); + k1 *= c2; + + h1 ^= k1; + h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13); + h1 = h1*5+0xe6546b64; + } + + +// Don't define 64-bit hash combine on platforms with 64 bit integers, +// and also not for 32-bit gcc as it warns about the 64-bit constant. +#if !defined(BOOST_NO_INT64_T) && \ + !(defined(__GNUC__) && ULONG_MAX == 0xffffffff) + + template + inline void hash_combine_impl(boost::uint64_t& h, + boost::uint64_t k) + { + const uint64_t m = UINT64_C(0xc6a4a7935bd1e995); + const int r = 47; + + k *= m; + k ^= k >> r; + k *= m; + + h ^= k; + h *= m; + } + +#endif // BOOST_NO_INT64_T } template @@ -244,16 +306,11 @@ namespace boost #endif #endif -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template - inline void hash_combine(std::size_t& seed, T& v) -#else template inline void hash_combine(std::size_t& seed, T const& v) -#endif { boost::hash hasher; - seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2); + return boost::hash_detail::hash_combine_impl(seed, hasher(v)); } #if defined(BOOST_MSVC) @@ -358,27 +415,6 @@ namespace boost // // These are undefined later. -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) -#define BOOST_HASH_SPECIALIZE(type) \ - template <> struct hash \ - : public std::unary_function \ - { \ - std::size_t operator()(type v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; - -#define BOOST_HASH_SPECIALIZE_REF(type) \ - template <> struct hash \ - : public std::unary_function \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; -#else #define BOOST_HASH_SPECIALIZE(type) \ template <> struct hash \ : public std::unary_function \ @@ -387,15 +423,6 @@ namespace boost { \ return boost::hash_value(v); \ } \ - }; \ - \ - template <> struct hash \ - : public std::unary_function \ - { \ - std::size_t operator()(const type v) const \ - { \ - return boost::hash_value(v); \ - } \ }; #define BOOST_HASH_SPECIALIZE_REF(type) \ @@ -406,17 +433,7 @@ namespace boost { \ return boost::hash_value(v); \ } \ - }; \ - \ - template <> struct hash \ - : public std::unary_function \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return boost::hash_value(v); \ - } \ }; -#endif BOOST_HASH_SPECIALIZE(bool) BOOST_HASH_SPECIALIZE(char) @@ -524,6 +541,7 @@ namespace boost } #undef BOOST_HASH_CHAR_TRAITS +#undef BOOST_FUNCTIONAL_HASH_ROTL32 #if defined(BOOST_MSVC) #pragma warning(pop) diff --git a/src/thirdparty/boost_lib/boost/functional/hash/hash_fwd.hpp b/src/thirdparty/boost_lib/boost/functional/hash/hash_fwd.hpp index 1d51b07f2..01fe012ed 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash/hash_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash/hash_fwd.hpp @@ -10,11 +10,11 @@ #if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP) #define BOOST_FUNCTIONAL_HASH_FWD_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once #endif -#include #include #include @@ -22,11 +22,7 @@ namespace boost { template struct hash; -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template void hash_combine(std::size_t& seed, T& v); -#else template void hash_combine(std::size_t& seed, T const& v); -#endif template std::size_t hash_range(It, It); template void hash_range(std::size_t&, It, It); diff --git a/src/thirdparty/boost_lib/boost/functional/hash_fwd.hpp b/src/thirdparty/boost_lib/boost/functional/hash_fwd.hpp index b64098861..eea907388 100644 --- a/src/thirdparty/boost_lib/boost/functional/hash_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/functional/hash_fwd.hpp @@ -3,5 +3,9 @@ // 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 +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#endif +#include diff --git a/src/thirdparty/boost_lib/boost/implicit_cast.hpp b/src/thirdparty/boost_lib/boost/implicit_cast.hpp index 5b1cd92b9..d82db7628 100644 --- a/src/thirdparty/boost_lib/boost/implicit_cast.hpp +++ b/src/thirdparty/boost_lib/boost/implicit_cast.hpp @@ -5,17 +5,24 @@ #ifndef IMPLICIT_CAST_DWA200356_HPP # define IMPLICIT_CAST_DWA200356_HPP -# include - namespace boost { +namespace detail { + +template struct icast_identity +{ + typedef T type; +}; + +} // namespace detail + // implementation originally suggested by C. Green in // http://lists.boost.org/MailArchives/boost/msg00886.php // The use of identity creates a non-deduced form, so that the // explicit template argument must be supplied template -inline T implicit_cast (typename mpl::identity::type x) { +inline T implicit_cast (typename boost::detail::icast_identity::type x) { return x; } diff --git a/src/thirdparty/boost_lib/boost/integer/integer_log2.hpp b/src/thirdparty/boost_lib/boost/integer/integer_log2.hpp new file mode 100644 index 000000000..8b34ce744 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/integer/integer_log2.hpp @@ -0,0 +1,112 @@ +// ----------------------------------------------------------- +// integer_log2.hpp +// +// Gives the integer part of the logarithm, in base 2, of a +// given number. Behavior is undefined if the argument is <= 0. +// +// Copyright (c) 2003-2004, 2008 Gennaro Prota +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// ----------------------------------------------------------- + +#ifndef BOOST_INTEGER_INTEGER_LOG2_HPP +#define BOOST_INTEGER_INTEGER_LOG2_HPP + +#include +#ifdef __BORLANDC__ +#include +#endif +#include +#include + + +namespace boost { + namespace detail { + + template + int integer_log2_impl(T x, int n) { + + int result = 0; + + while (x != 1) { + + const T t = static_cast(x >> n); + if (t) { + result += n; + x = t; + } + n /= 2; + + } + + return result; + } + + + + // helper to find the maximum power of two + // less than p (more involved than necessary, + // to avoid PTS) + // + template + struct max_pow2_less { + + enum { c = 2*n < p }; + + BOOST_STATIC_CONSTANT(int, value = + c ? (max_pow2_less< c*p, 2*c*n>::value) : n); + + }; + + template <> + struct max_pow2_less<0, 0> { + + BOOST_STATIC_CONSTANT(int, value = 0); + }; + + // this template is here just for Borland :( + // we could simply rely on numeric_limits but sometimes + // Borland tries to use numeric_limits, because + // of its usual const-related problems in argument deduction + // - gps + template + struct width { + +#ifdef __BORLANDC__ + BOOST_STATIC_CONSTANT(int, value = sizeof(T) * CHAR_BIT); +#else + BOOST_STATIC_CONSTANT(int, value = (std::numeric_limits::digits)); +#endif + + }; + + } // detail + + + // --------- + // integer_log2 + // --------------- + // + template + int integer_log2(T x) { + + assert(x > 0); + + const int n = detail::max_pow2_less< + detail::width :: value, 4 + > :: value; + + return detail::integer_log2_impl(x, n); + + } + + + +} + + + +#endif // include guard diff --git a/src/thirdparty/boost_lib/boost/integer_traits.hpp b/src/thirdparty/boost_lib/boost/integer_traits.hpp index d896e46e5..94eb00d31 100644 --- a/src/thirdparty/boost_lib/boost/integer_traits.hpp +++ b/src/thirdparty/boost_lib/boost/integer_traits.hpp @@ -5,7 +5,7 @@ * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * - * $Id: integer_traits.hpp 85813 2013-09-21 20:17:00Z jewillco $ + * $Id$ * * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers */ @@ -119,11 +119,6 @@ class integer_traits // - Mac OS X with native library // - gcc on FreeBSD, OpenBSD and NetBSD public detail::integer_traits_base -#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT) - // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int. - // - gcc 2.95.x on HP-UX - // (also, std::numeric_limits appears to return the wrong values). - public detail::integer_traits_base #else #error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler. #endif diff --git a/src/thirdparty/boost_lib/boost/iterator.hpp b/src/thirdparty/boost_lib/boost/iterator.hpp index 6adab0e69..c9c619795 100644 --- a/src/thirdparty/boost_lib/boost/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/iterator.hpp @@ -1,59 +1,20 @@ -// iterator.hpp workarounds for non-conforming standard libraries ---------// - // (C) Copyright Beman Dawes 2000. 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/utility for documentation. - -// Revision History -// 12 Jan 01 added for std::ptrdiff_t (Jens Maurer) -// 28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams) -// 26 Jun 00 Initial version (Jeremy Siek) - #ifndef BOOST_ITERATOR_HPP #define BOOST_ITERATOR_HPP +// This header is obsolete and will be deprecated. + #include #include // std::ptrdiff_t -#include namespace boost { -# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR) - template - struct iterator - { - typedef T value_type; - typedef Distance difference_type; - typedef Pointer pointer; - typedef Reference reference; - typedef Category iterator_category; - }; -# else - // declare iterator_base in namespace detail to work around MSVC bugs which - // prevent derivation from an identically-named class in a different namespace. - namespace detail { - template -# if !defined(BOOST_MSVC_STD_ITERATOR) - struct iterator_base : std::iterator {}; -# else - struct iterator_base : std::iterator - { - typedef Reference reference; - typedef Pointer pointer; - typedef Distance difference_type; - }; -# endif - } +using std::iterator; - template - struct iterator : boost::detail::iterator_base {}; -# endif } // namespace boost #endif // BOOST_ITERATOR_HPP diff --git a/src/thirdparty/boost_lib/boost/iterator/detail/facade_iterator_category.hpp b/src/thirdparty/boost_lib/boost/iterator/detail/facade_iterator_category.hpp index 2c4771d5a..04b393acf 100644 --- a/src/thirdparty/boost_lib/boost/iterator/detail/facade_iterator_category.hpp +++ b/src/thirdparty/boost_lib/boost/iterator/detail/facade_iterator_category.hpp @@ -73,16 +73,10 @@ struct iterator_writability_disabled // Convert an iterator_facade's traversal category, Value parameter, // and ::reference type to an appropriate old-style category. // -// If writability has been disabled per the above metafunction, the -// result will not be convertible to output_iterator_tag. -// -// Otherwise, if Traversal == single_pass_traversal_tag, the following -// conditions will result in a tag that is convertible both to -// input_iterator_tag and output_iterator_tag: -// -// 1. Reference is a reference to non-const -// 2. Reference is not a reference and is convertible to Value +// Due to changeset 21683, this now never results in a category convertible +// to output_iterator_tag. // +// Change at: https://svn.boost.org/trac/boost/changeset/21683 template struct iterator_facade_default_category : mpl::eval_if< diff --git a/src/thirdparty/boost_lib/boost/iterator/detail/operator_brackets_dispatch.hpp b/src/thirdparty/boost_lib/boost/iterator/detail/operator_brackets_dispatch.hpp new file mode 100644 index 000000000..fdbd92954 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/iterator/detail/operator_brackets_dispatch.hpp @@ -0,0 +1,88 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// (C) Copyright Jeffrey Lee Hellrung, Jr. 2012. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_OPERATOR_BRACKETS_DISPATCH_07102012JLH_HPP +#define BOOST_OPERATOR_BRACKETS_DISPATCH_07102012JLH_HPP + +#include + +#include +#include + +#include + +namespace boost { namespace detail { + +// operator[] must return a proxy in case iterator destruction invalidates +// referents. +// To see why, consider the following implementation of operator[]: +// reference operator[](difference_type n) const +// { return *(*this + n); } +// The problem here is that operator[] would return a reference created from +// a temporary iterator. + +template +struct operator_brackets_value +{ + typedef Value result_type; + template + static result_type apply(Iterator const & i) + { return *i; } +}; + +template +struct operator_brackets_const_proxy +{ + class result_type + { + Iterator const m_i; + explicit result_type(Iterator const & i) : m_i(i) { } + friend struct operator_brackets_const_proxy; + void operator=(result_type&); + public: + operator Reference() const { return *m_i; } + }; + static result_type apply(Iterator const & i) + { return result_type(i); } +}; + +template +struct operator_brackets_proxy +{ + class result_type + { + Iterator const m_i; + explicit result_type(Iterator const & i) : m_i(i) { } + friend struct operator_brackets_proxy; + void operator=(result_type&); + public: + operator Reference() const { return *m_i; } + operator_brackets_proxy const & operator=( + typename Iterator::value_type const & x) const + { *m_i = x; return *this; } + }; + static result_type apply(Iterator const & i) + { return result_type(i); } +}; + +template +struct operator_brackets_dispatch +{ + typedef typename mpl::if_c< + iterator_writability_disabled::value, + typename mpl::if_c< + boost::is_POD::value, + operator_brackets_value::type>, + operator_brackets_const_proxy + >::type, + operator_brackets_proxy + >::type type; +}; + +} } // namespace detail / namespace boost + +#endif // #ifndef BOOST_OPERATOR_BRACKETS_DISPATCH_07102012JLH_HPP diff --git a/src/thirdparty/boost_lib/boost/lexical_cast.hpp b/src/thirdparty/boost_lib/boost/lexical_cast.hpp index ed2291d85..814b69e43 100644 --- a/src/thirdparty/boost_lib/boost/lexical_cast.hpp +++ b/src/thirdparty/boost_lib/boost/lexical_cast.hpp @@ -3,7 +3,7 @@ // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -19,7 +19,7 @@ // Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, // Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, // Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters -// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2013 +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 #include #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING) @@ -87,50 +87,39 @@ namespace boost { public: - bad_lexical_cast() BOOST_NOEXCEPT : + bad_lexical_cast() BOOST_NOEXCEPT #ifndef BOOST_NO_TYPEID - source(&typeid(void)), target(&typeid(void)) -#else - source(0), target(0) // this breaks getters + : source(&typeid(void)), target(&typeid(void)) #endif - { + {} + + virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW { + return "bad lexical cast: " + "source type value could not be interpreted as target"; } + virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW + {} + +#ifndef BOOST_NO_TYPEID bad_lexical_cast( - const std::type_info &source_type_arg, - const std::type_info &target_type_arg) BOOST_NOEXCEPT : - source(&source_type_arg), target(&target_type_arg) - { - } + const std::type_info &source_type_arg, + const std::type_info &target_type_arg) BOOST_NOEXCEPT + : source(&source_type_arg), target(&target_type_arg) + {} - const std::type_info &source_type() const - { + const std::type_info &source_type() const BOOST_NOEXCEPT { return *source; } - const std::type_info &target_type() const - { - return *target; - } -#ifndef BOOST_NO_CXX11_NOEXCEPT - virtual const char *what() const noexcept -#else - virtual const char *what() const throw() -#endif - { - return "bad lexical cast: " - "source type value could not be interpreted as target"; + const std::type_info &target_type() const BOOST_NOEXCEPT { + return *target; } -#ifndef BOOST_NO_CXX11_NOEXCEPT - virtual ~bad_lexical_cast() BOOST_NOEXCEPT -#else - virtual ~bad_lexical_cast() throw() -#endif - {} private: const std::type_info *source; const std::type_info *target; +#endif }; namespace detail // widest_char @@ -146,7 +135,7 @@ namespace boost } } // namespace boost -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC) && !defined(__PGIC__) +#if !defined(__SUNPRO_CC) && !defined(__PGIC__) #include #include @@ -169,17 +158,19 @@ namespace boost #include #include #include +#include +#include #ifndef BOOST_NO_CWCHAR # include #endif namespace boost { - namespace detail // is_char_or_wchar<...> + namespace detail // is_character<...> { // returns true, if T is one of the character types template < typename T > - struct is_char_or_wchar + struct is_character { typedef boost::type_traits::ice_or< boost::is_same< T, char >::value, @@ -236,35 +227,35 @@ namespace boost { // Executed on Stage 1 (See deduce_source_char and deduce_target_char) template < typename Type > struct stream_char_common: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Type >::value, + boost::detail::is_character< Type >::value, Type, boost::detail::deduce_character_type_later< Type > > {}; template < typename Char > struct stream_char_common< Char* >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< Char* > > {}; template < typename Char > struct stream_char_common< const Char* >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< const Char* > > {}; template < typename Char > struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< boost::iterator_range< Char* > > > {}; template < typename Char > struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > > > {}; @@ -283,14 +274,14 @@ namespace boost { template < typename Char, std::size_t N > struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< boost::array< Char, N > > > {}; template < typename Char, std::size_t N > struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< boost::array< const Char, N > > > {}; @@ -298,14 +289,14 @@ namespace boost { #ifndef BOOST_NO_CXX11_HDR_ARRAY template < typename Char, std::size_t N > struct stream_char_common< std::array >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< std::array< Char, N > > > {}; template < typename Char, std::size_t N > struct stream_char_common< std::array< const Char, N > >: public boost::mpl::if_c< - boost::detail::is_char_or_wchar< Char >::value, + boost::detail::is_character< Char >::value, Char, boost::detail::deduce_character_type_later< std::array< const Char, N > > > {}; @@ -427,86 +418,29 @@ namespace boost { }; } - namespace detail // deduce_char_traits template + namespace detail // extract_char_traits template { - // We are attempting to get char_traits<> from Source or Tagret + // We are attempting to get char_traits<> from T // template parameter. Otherwise we'll be using std::char_traits - template < class Char, class Target, class Source > - struct deduce_char_traits - { - typedef std::char_traits< Char > type; - }; - - template < class Char, class Traits, class Alloc, class Source > - struct deduce_char_traits< Char - , std::basic_string< Char, Traits, Alloc > - , Source - > - { - typedef Traits type; - }; - - template < class Char, class Target, class Traits, class Alloc > - struct deduce_char_traits< Char - , Target - , std::basic_string< Char, Traits, Alloc > - > + template < class Char, class T > + struct extract_char_traits + : boost::false_type { - typedef Traits type; + typedef std::char_traits< Char > trait_t; }; - template < class Char, class Traits, class Alloc, class Source > - struct deduce_char_traits< Char - , boost::container::basic_string< Char, Traits, Alloc > - , Source - > - { - typedef Traits type; - }; - - template < class Char, class Target, class Traits, class Alloc > - struct deduce_char_traits< Char - , Target - , boost::container::basic_string< Char, Traits, Alloc > - > - { - typedef Traits type; - }; - - template < class Char, class Traits, class Alloc1, class Alloc2 > - struct deduce_char_traits< Char - , std::basic_string< Char, Traits, Alloc1 > - , std::basic_string< Char, Traits, Alloc2 > - > - { - typedef Traits type; - }; - - template - struct deduce_char_traits< Char - , boost::container::basic_string< Char, Traits, Alloc1 > - , boost::container::basic_string< Char, Traits, Alloc2 > - > - { - typedef Traits type; - }; - - template < class Char, class Traits, class Alloc1, class Alloc2 > - struct deduce_char_traits< Char - , boost::container::basic_string< Char, Traits, Alloc1 > - , std::basic_string< Char, Traits, Alloc2 > - > + template < class Char, class Traits, class Alloc > + struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > > + : boost::true_type { - typedef Traits type; + typedef Traits trait_t; }; - template < class Char, class Traits, class Alloc1, class Alloc2 > - struct deduce_char_traits< Char - , std::basic_string< Char, Traits, Alloc1 > - , boost::container::basic_string< Char, Traits, Alloc2 > - > + template < class Char, class Traits, class Alloc> + struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > > + : boost::true_type { - typedef Traits type; + typedef Traits trait_t; }; } @@ -552,14 +486,12 @@ namespace boost { namespace detail // lcast_src_length { // Return max. length of string representation of Source; - template< class Source // Source type of lexical_cast. + template< class Source, // Source type of lexical_cast. + class Enable = void // helper type > struct lcast_src_length { BOOST_STATIC_CONSTANT(std::size_t, value = 1); - // To check coverage, build the test with - // bjam --v2 profile optimization=off - static void check_coverage() {} }; // Helper for integral types. @@ -575,8 +507,10 @@ namespace boost { // doesn't add missing specialization for // numeric_limits for some integral type T. // When is_specialized is false, the whole expression is 0. - template - struct lcast_src_length_integral + template + struct lcast_src_length< + Source, BOOST_DEDUCED_TYPENAME boost::enable_if >::type + > { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_CONSTANT(std::size_t, value = @@ -590,31 +524,6 @@ namespace boost { #endif }; -#define BOOST_LCAST_DEF(T) \ - template<> struct lcast_src_length \ - : lcast_src_length_integral \ - { static void check_coverage() {} }; - - BOOST_LCAST_DEF(short) - BOOST_LCAST_DEF(unsigned short) - BOOST_LCAST_DEF(int) - BOOST_LCAST_DEF(unsigned int) - BOOST_LCAST_DEF(long) - BOOST_LCAST_DEF(unsigned long) -#if defined(BOOST_HAS_LONG_LONG) - BOOST_LCAST_DEF(boost::ulong_long_type) - BOOST_LCAST_DEF(boost::long_long_type ) -#elif defined(BOOST_HAS_MS_INT64) - BOOST_LCAST_DEF(unsigned __int64) - BOOST_LCAST_DEF( __int64) -#endif -#ifdef BOOST_HAS_INT128 - BOOST_LCAST_DEF(boost::int128_type) - BOOST_LCAST_DEF(boost::uint128_type) -#endif - -#undef BOOST_LCAST_DEF - #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION // Helper for floating point types. // -1.23456789e-123456 @@ -627,38 +536,19 @@ namespace boost { // ^^^^^^ exponent (assumed 6 or less digits) // sign + leading digit + decimal point + "e" + exponent sign == 5 template - struct lcast_src_length_floating + struct lcast_src_length< + Source, BOOST_DEDUCED_TYPENAME boost::enable_if >::type + > { BOOST_STATIC_ASSERT( std::numeric_limits::max_exponent10 <= 999999L && std::numeric_limits::min_exponent10 >= -999999L ); + BOOST_STATIC_CONSTANT(std::size_t, value = 5 + lcast_precision::value + 6 ); }; - - template<> - struct lcast_src_length - : lcast_src_length_floating - { - static void check_coverage() {} - }; - - template<> - struct lcast_src_length - : lcast_src_length_floating - { - static void check_coverage() {} - }; - - template<> - struct lcast_src_length - : lcast_src_length_floating - { - static void check_coverage() {} - }; - #endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION } @@ -688,22 +578,24 @@ namespace boost { "Your compiler does not have full support for char32_t" ); #endif - typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_char_traits< - char_type, Target, no_cv_src - >::type traits; + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + boost::detail::extract_char_traits::value, + BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits, + BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits + >::type::trait_t traits; typedef boost::type_traits::ice_and< boost::is_same::value, // source is not a wide character based type boost::type_traits::ice_ne::value, // target type is based on wide character boost::type_traits::ice_not< - boost::detail::is_char_or_wchar::value // single character widening is optimized + boost::detail::is_character::value // single character widening is optimized >::value // and does not requires stringbuffer > is_string_widening_required_t; typedef boost::type_traits::ice_not< boost::type_traits::ice_or< boost::is_integral::value, boost::detail::is_this_float_conversion_optimized::value, - boost::detail::is_char_or_wchar< + boost::detail::is_character< BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1 >::value // then we have no optimization for that type >::value > is_source_input_not_optimized_t; @@ -720,184 +612,166 @@ namespace boost { }; } - namespace detail // '0', '+' and '-' constants + namespace detail // '0', '-', '+', 'e', 'E' and '.' constants { - template < typename Char > struct lcast_char_constants; - - template<> - struct lcast_char_constants - { - BOOST_STATIC_CONSTANT(char, zero = '0'); - BOOST_STATIC_CONSTANT(char, minus = '-'); - BOOST_STATIC_CONSTANT(char, plus = '+'); - BOOST_STATIC_CONSTANT(char, lowercase_e = 'e'); - BOOST_STATIC_CONSTANT(char, capital_e = 'E'); - BOOST_STATIC_CONSTANT(char, c_decimal_separator = '.'); - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_char_constants - { - BOOST_STATIC_CONSTANT(wchar_t, zero = L'0'); - BOOST_STATIC_CONSTANT(wchar_t, minus = L'-'); - BOOST_STATIC_CONSTANT(wchar_t, plus = L'+'); - BOOST_STATIC_CONSTANT(wchar_t, lowercase_e = L'e'); - BOOST_STATIC_CONSTANT(wchar_t, capital_e = L'E'); - BOOST_STATIC_CONSTANT(wchar_t, c_decimal_separator = L'.'); - }; -#endif - -#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - template<> - struct lcast_char_constants - { - BOOST_STATIC_CONSTANT(char16_t, zero = u'0'); - BOOST_STATIC_CONSTANT(char16_t, minus = u'-'); - BOOST_STATIC_CONSTANT(char16_t, plus = u'+'); - BOOST_STATIC_CONSTANT(char16_t, lowercase_e = u'e'); - BOOST_STATIC_CONSTANT(char16_t, capital_e = u'E'); - BOOST_STATIC_CONSTANT(char16_t, c_decimal_separator = u'.'); - }; -#endif - -#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - template<> - struct lcast_char_constants - { - BOOST_STATIC_CONSTANT(char32_t, zero = U'0'); - BOOST_STATIC_CONSTANT(char32_t, minus = U'-'); - BOOST_STATIC_CONSTANT(char32_t, plus = U'+'); - BOOST_STATIC_CONSTANT(char32_t, lowercase_e = U'e'); - BOOST_STATIC_CONSTANT(char32_t, capital_e = U'E'); - BOOST_STATIC_CONSTANT(char32_t, c_decimal_separator = U'.'); + template < typename Char > + struct lcast_char_constants { + // We check in tests assumption that static casted character is + // equal to correctly written C++ literal: U'0' == static_cast('0') + BOOST_STATIC_CONSTANT(Char, zero = static_cast('0')); + BOOST_STATIC_CONSTANT(Char, minus = static_cast('-')); + BOOST_STATIC_CONSTANT(Char, plus = static_cast('+')); + BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast('e')); + BOOST_STATIC_CONSTANT(Char, capital_e = static_cast('E')); + BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast('.')); }; -#endif } namespace detail // lcast_to_unsigned { template inline - BOOST_DEDUCED_TYPENAME make_unsigned::type lcast_to_unsigned(T value) BOOST_NOEXCEPT - { + BOOST_DEDUCED_TYPENAME boost::make_unsigned::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT { typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned::type result_type; - return static_cast( - value < 0 ? 0u - static_cast(value) : value - ); + return value < 0 + ? static_cast(0u - static_cast(value)) + : static_cast(value); } } namespace detail // lcast_put_unsigned { - template - CharT* lcast_put_unsigned(const T n_param, CharT* finish) - { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits::is_signed); -#endif - - typedef typename Traits::int_type int_type; - CharT const czero = lcast_char_constants::zero; - int_type const zero = Traits::to_int_type(czero); + template + class lcast_put_unsigned: boost::noncopyable { + typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type; BOOST_DEDUCED_TYPENAME boost::mpl::if_c< (sizeof(int_type) > sizeof(T)) , int_type , T - >::type n = n_param; + >::type m_value; + CharT* m_finish; + CharT const m_czero; + int_type const m_zero; + + public: + lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT + : m_value(n_param), m_finish(finish) + , m_czero(lcast_char_constants::zero), m_zero(Traits::to_int_type(m_czero)) + { +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + BOOST_STATIC_ASSERT(!std::numeric_limits::is_signed); +#endif + } + CharT* convert() { #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - std::locale loc; - if (loc != std::locale::classic()) { + std::locale loc; + if (loc == std::locale::classic()) { + return main_convert_loop(); + } + typedef std::numpunct numpunct; numpunct const& np = BOOST_USE_FACET(numpunct, loc); std::string const grouping = np.grouping(); std::string::size_type const grouping_size = grouping.size(); - if ( grouping_size && grouping[0] > 0 ) - { + if (!grouping_size || grouping[0] <= 0) { + return main_convert_loop(); + } #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS // Check that ulimited group is unreachable: BOOST_STATIC_ASSERT(std::numeric_limits::digits10 < CHAR_MAX); #endif - CharT thousands_sep = np.thousands_sep(); - std::string::size_type group = 0; // current group number - char last_grp_size = grouping[0]; - char left = last_grp_size; - - do - { - if(left == 0) - { - ++group; - if(group < grouping_size) - { - char const grp_size = grouping[group]; - last_grp_size = grp_size <= 0 ? static_cast(CHAR_MAX) : grp_size; - } - - left = last_grp_size; - --finish; - Traits::assign(*finish, thousands_sep); + CharT const thousands_sep = np.thousands_sep(); + std::string::size_type group = 0; // current group number + char last_grp_size = grouping[0]; + char left = last_grp_size; + + do { + if (left == 0) { + ++group; + if (group < grouping_size) { + char const grp_size = grouping[group]; + last_grp_size = (grp_size <= 0 ? static_cast(CHAR_MAX) : grp_size); } - --left; + left = last_grp_size; + --m_finish; + Traits::assign(*m_finish, thousands_sep); + } + + --left; + } while (main_convert_itaration()); - --finish; - int_type const digit = static_cast(n % 10U); - Traits::assign(*finish, Traits::to_char_type(zero + digit)); - n /= 10; - } while(n); - return finish; - } - } + return m_finish; +#else + return main_convert_loop(); #endif - { - do - { - --finish; - int_type const digit = static_cast(n % 10U); - Traits::assign(*finish, Traits::to_char_type(zero + digit)); - n /= 10; - } while(n); } - return finish; - } + private: + inline bool main_convert_itaration() BOOST_NOEXCEPT { + --m_finish; + int_type const digit = static_cast(m_value % 10U); + Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit)); + m_value /= 10; + return !!m_value; // supressing warnings + } + + inline CharT* main_convert_loop() BOOST_NOEXCEPT { + while (main_convert_itaration()); + return m_finish; + } + }; } namespace detail // lcast_ret_unsigned { - template - inline bool lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) - { + template + class lcast_ret_unsigned: boost::noncopyable { + bool m_multiplier_overflowed; + T m_multiplier; + T& m_value; + const CharT* const m_begin; + const CharT* m_end; + + public: + lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT + : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end) + { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits::is_signed); - - // GCC when used with flag -std=c++0x may not have std::numeric_limits - // specializations for __int128 and unsigned __int128 types. - // Try compilation with -std=gnu++0x or -std=gnu++11. - // - // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856 - BOOST_STATIC_ASSERT_MSG(std::numeric_limits::is_specialized, - "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast" - ); + BOOST_STATIC_ASSERT(!std::numeric_limits::is_signed); + + // GCC when used with flag -std=c++0x may not have std::numeric_limits + // specializations for __int128 and unsigned __int128 types. + // Try compilation with -std=gnu++0x or -std=gnu++11. + // + // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856 + BOOST_STATIC_ASSERT_MSG(std::numeric_limits::is_specialized, + "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast" + ); #endif - CharT const czero = lcast_char_constants::zero; - --end; - value = 0; + } - if (begin > end || *end < czero || *end >= czero + 10) - return false; - value = static_cast(*end - czero); - --end; - T multiplier = 1; - bool multiplier_overflowed = false; + inline bool convert() { + CharT const czero = lcast_char_constants::zero; + --m_end; + m_value = static_cast(0); + + if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10) + return false; + m_value = static_cast(*m_end - czero); + --m_end; + +#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + return main_convert_loop(); +#else + std::locale loc; + if (loc == std::locale::classic()) { + return main_convert_loop(); + } -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - std::locale loc; - if (loc != std::locale::classic()) { typedef std::numpunct numpunct; numpunct const& np = BOOST_USE_FACET(numpunct, loc); std::string const& grouping = np.grouping(); @@ -906,85 +780,86 @@ namespace boost { /* According to Programming languages - C++ * we MUST check for correct grouping */ - if (grouping_size && grouping[0] > 0) + if (!grouping_size || grouping[0] <= 0) { + return main_convert_loop(); + } + + unsigned char current_grouping = 0; + CharT const thousands_sep = np.thousands_sep(); + char remained = static_cast(grouping[current_grouping] - 1); + + for (;m_end >= m_begin; --m_end) { - unsigned char current_grouping = 0; - CharT const thousands_sep = np.thousands_sep(); - char remained = static_cast(grouping[current_grouping] - 1); - bool shall_we_return = true; - - for(;end>=begin; --end) - { - if (remained) { - T const multiplier_10 = static_cast(multiplier * 10); - if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true; - - T const dig_value = static_cast(*end - czero); - T const new_sub_value = static_cast(multiplier_10 * dig_value); - - if (*end < czero || *end >= czero + 10 - /* detecting overflow */ - || (dig_value && new_sub_value / dig_value != multiplier_10) - || static_cast((std::numeric_limits::max)()-new_sub_value) < value - || (multiplier_overflowed && dig_value) - ) - return false; - - value = static_cast(value + new_sub_value); - multiplier = static_cast(multiplier * 10); - --remained; + if (remained) { + if (!main_convert_itaration()) { + return false; + } + --remained; + } else { + if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false; + { + /* + * According to Programming languages - C++ + * Digit grouping is checked. That is, the positions of discarded + * separators is examined for consistency with + * use_facet >(loc ).grouping() + * + * BUT what if there is no separators at all and grouping() + * is not empty? Well, we have no extraced separators, so we + * won`t check them for consistency. This will allow us to + * work with "C" locale from other locales + */ + return main_convert_loop(); } else { - if ( !Traits::eq(*end, thousands_sep) ) //|| begin == end ) return false; - { - /* - * According to Programming languages - C++ - * Digit grouping is checked. That is, the positions of discarded - * separators is examined for consistency with - * use_facet >(loc ).grouping() - * - * BUT what if there is no separators at all and grouping() - * is not empty? Well, we have no extraced separators, so we - * won`t check them for consistency. This will allow us to - * work with "C" locale from other locales - */ - shall_we_return = false; - break; - } else { - if ( begin == end ) return false; - if (current_grouping < grouping_size-1 ) ++current_grouping; - remained = grouping[current_grouping]; - } + if (m_begin == m_end) return false; + if (current_grouping < grouping_size - 1) ++current_grouping; + remained = grouping[current_grouping]; } } + } /*for*/ - if (shall_we_return) return true; - } - } + return true; #endif - { - while ( begin <= end ) - { - T const multiplier_10 = static_cast(multiplier * 10); - if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true; + } + + private: + // Iteration that does not care about grouping/separators and assumes that all + // input characters are digits + inline bool main_convert_itaration() BOOST_NOEXCEPT { + CharT const czero = lcast_char_constants::zero; + T const maxv = (std::numeric_limits::max)(); + + m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier); + m_multiplier = static_cast(m_multiplier * 10); + + T const dig_value = static_cast(*m_end - czero); + T const new_sub_value = static_cast(m_multiplier * dig_value); + + // We must correctly handle situations like `000000000000000000000000000001`. + // So we take care of overflow only if `dig_value` is not '0'. + if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit + || (dig_value && ( // checking for overflow of ... + m_multiplier_overflowed // ... multiplier + || static_cast(maxv / dig_value) < m_multiplier // ... subvalue + || static_cast(maxv - new_sub_value) < m_value // ... whole expression + )) + ) return false; - T const dig_value = static_cast(*end - czero); - T const new_sub_value = static_cast(multiplier_10 * dig_value); + m_value = static_cast(m_value + new_sub_value); + + return true; + } - if (*end < czero || *end >= czero + 10 - /* detecting overflow */ - || (dig_value && new_sub_value / dig_value != multiplier_10) - || static_cast((std::numeric_limits::max)()-new_sub_value) < value - || (multiplier_overflowed && dig_value) - ) + bool main_convert_loop() BOOST_NOEXCEPT { + for ( ; m_end >= m_begin; --m_end) { + if (!main_convert_itaration()) { return false; - - value = static_cast(value + new_sub_value); - multiplier = static_cast(multiplier * 10); - --end; + } } + + return true; } - return true; - } + }; } namespace detail @@ -1009,42 +884,37 @@ namespace boost { if (begin == end) return false; const CharT minus = lcast_char_constants::minus; const CharT plus = lcast_char_constants::plus; - const int inifinity_size = 8; + const int inifinity_size = 8; // == sizeof("infinity") - 1 - bool has_minus = false; /* Parsing +/- */ - if( *begin == minus) - { + bool const has_minus = (*begin == minus); + if (has_minus || *begin == plus) { ++ begin; - has_minus = true; } - else if( *begin == plus ) ++begin; - if( end-begin < 3 ) return false; - if( lc_iequal(begin, lc_nan, lc_NAN, 3) ) - { + if (end - begin < 3) return false; + if (lc_iequal(begin, lc_nan, lc_NAN, 3)) { begin += 3; - if (end != begin) /* It is 'nan(...)' or some bad input*/ - { - if(end-begin<2) return false; // bad input + if (end != begin) { + /* It is 'nan(...)' or some bad input*/ + + if (end - begin < 2) return false; // bad input -- end; - if( *begin != opening_brace || *end != closing_brace) return false; // bad input + if (*begin != opening_brace || *end != closing_brace) return false; // bad input } if( !has_minus ) value = std::numeric_limits::quiet_NaN(); else value = (boost::math::changesign) (std::numeric_limits::quiet_NaN()); return true; - } else - if (( /* 'INF' or 'inf' */ - end-begin==3 - && - lc_iequal(begin, lc_infinity, lc_INFINITY, 3) + } else if ( + ( /* 'INF' or 'inf' */ + end - begin == 3 // 3 == sizeof('inf') - 1 + && lc_iequal(begin, lc_infinity, lc_INFINITY, 3) ) || ( /* 'INFINITY' or 'infinity' */ - end-begin==inifinity_size - && - lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size) + end - begin == inifinity_size + && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size) ) ) { @@ -1063,10 +933,8 @@ namespace boost { { using namespace std; const CharT minus = lcast_char_constants::minus; - if ( (boost::math::isnan)(value) ) - { - if ( (boost::math::signbit)(value) ) - { + if ((boost::math::isnan)(value)) { + if ((boost::math::signbit)(value)) { *begin = minus; ++ begin; } @@ -1074,10 +942,8 @@ namespace boost { memcpy(begin, lc_nan, 3 * sizeof(CharT)); end = begin + 3; return true; - } else if ( (boost::math::isinf)(value) ) - { - if ( (boost::math::signbit)(value) ) - { + } else if ((boost::math::isinf)(value)) { + if ((boost::math::signbit)(value)) { *begin = minus; ++ begin; } @@ -1093,8 +959,7 @@ namespace boost { #ifndef BOOST_LCAST_NO_WCHAR_T template - bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT - { + bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT { return parse_inf_nan_impl(begin, end, value , L"NAN", L"nan" , L"INFINITY", L"infinity" @@ -1102,16 +967,14 @@ namespace boost { } template - bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT - { + bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT { return put_inf_nan_impl(begin, end, value, L"nan", L"infinity"); } #endif #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) template - bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT - { + bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT { return parse_inf_nan_impl(begin, end, value , u"NAN", u"nan" , u"INFINITY", u"infinity" @@ -1119,15 +982,13 @@ namespace boost { } template - bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT - { + bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT { return put_inf_nan_impl(begin, end, value, u"nan", u"infinity"); } #endif #if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) template - bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT - { + bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT { return parse_inf_nan_impl(begin, end, value , U"NAN", U"nan" , U"INFINITY", U"infinity" @@ -1135,15 +996,13 @@ namespace boost { } template - bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT - { + bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT { return put_inf_nan_impl(begin, end, value, U"nan", U"infinity"); } #endif template - bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT - { + bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT { return parse_inf_nan_impl(begin, end, value , "NAN", "nan" , "INFINITY", "infinity" @@ -1151,8 +1010,7 @@ namespace boost { } template - bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT - { + bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT { return put_inf_nan_impl(begin, end, value, "nan", "infinity"); } } @@ -1193,8 +1051,24 @@ namespace boost { }; template - inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* end) + inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* const end) { + value = static_cast(0); + if (begin == end) return false; + if (parse_inf_nan(begin, end, value)) return true; + + CharT const czero = lcast_char_constants::zero; + CharT const minus = lcast_char_constants::minus; + CharT const plus = lcast_char_constants::plus; + CharT const capital_e = lcast_char_constants::capital_e; + CharT const lowercase_e = lcast_char_constants::lowercase_e; + + /* Getting the plus/minus sign */ + bool const has_minus = Traits::eq(*begin, minus); + if (has_minus || Traits::eq(*begin, plus)) { + ++ begin; + if (begin == end) return false; + } #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE std::locale loc; @@ -1214,52 +1088,25 @@ namespace boost { CharT const decimal_point = lcast_char_constants::c_decimal_separator; #endif - CharT const czero = lcast_char_constants::zero; - CharT const minus = lcast_char_constants::minus; - CharT const plus = lcast_char_constants::plus; - CharT const capital_e = lcast_char_constants::capital_e; - CharT const lowercase_e = lcast_char_constants::lowercase_e; - - value = static_cast(0); - - if (parse_inf_nan(begin, end, value)) return true; - - typedef typename Traits::int_type int_type; - typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type::type mantissa_type; - typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type::wide_result_t wide_result_t; - int_type const zero = Traits::to_int_type(czero); - if (begin == end) return false; - - /* Getting the plus/minus sign */ - bool has_minus = false; - if (Traits::eq(*begin, minus) ) { - ++ begin; - has_minus = true; - if (begin == end) return false; - } else if (Traits::eq(*begin, plus) ) { - ++begin; - if (begin == end) return false; - } - bool found_decimal = false; bool found_number_before_exp = false; - int pow_of_10 = 0; + typedef int pow_of_10_t; + pow_of_10_t pow_of_10 = 0; + + typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type::type mantissa_type; mantissa_type mantissa=0; bool is_mantissa_full = false; - char length_since_last_delim = 0; - while ( begin != end ) - { + while (begin != end) { if (found_decimal) { /* We allow no thousand_separators after decimal point */ - mantissa_type tmp_mantissa = mantissa * 10u; + const mantissa_type tmp_sub_value = static_cast(*begin - czero); if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break; if ( *begin < czero || *begin >= czero + 10 ) return false; if ( is_mantissa_full - || tmp_mantissa / 10u != mantissa - || (std::numeric_limits::max)()-(*begin - zero) < tmp_mantissa + || ((std::numeric_limits::max)() - tmp_sub_value) / 10u < mantissa ) { is_mantissa_full = true; ++ begin; @@ -1267,8 +1114,7 @@ namespace boost { } -- pow_of_10; - mantissa = tmp_mantissa; - mantissa += *begin - zero; + mantissa = static_cast(mantissa * 10 + tmp_sub_value); found_number_before_exp = true; } else { @@ -1278,18 +1124,15 @@ namespace boost { /* Checking for mantissa overflow. If overflow will * occur, them we only increase multiplyer */ - mantissa_type tmp_mantissa = mantissa * 10u; - if( !is_mantissa_full - && tmp_mantissa / 10u == mantissa - && (std::numeric_limits::max)()-(*begin - zero) >= tmp_mantissa + const mantissa_type tmp_sub_value = static_cast(*begin - czero); + if( is_mantissa_full + || ((std::numeric_limits::max)() - tmp_sub_value) / 10u < mantissa ) - { - mantissa = tmp_mantissa; - mantissa += *begin - zero; - } else { is_mantissa_full = true; ++ pow_of_10; + } else { + mantissa = static_cast(mantissa * 10 + tmp_sub_value); } found_number_before_exp = true; @@ -1312,12 +1155,12 @@ namespace boost { ) return false; #endif - if(Traits::eq(*begin, decimal_point)) { + if (Traits::eq(*begin, decimal_point)) { ++ begin; found_decimal = true; if (!found_number_before_exp && begin==end) return false; continue; - }else { + } else { if (!found_number_before_exp) return false; break; } @@ -1365,52 +1208,48 @@ namespace boost { } // Exponent found - if ( begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) ) { + if (begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e))) { ++ begin; - if ( begin == end ) return false; + if (begin == end) return false; - bool exp_has_minus = false; - if(Traits::eq(*begin, minus)) { - exp_has_minus = true; + bool const exp_has_minus = Traits::eq(*begin, minus); + if (exp_has_minus || Traits::eq(*begin, plus)) { ++ begin; - if ( begin == end ) return false; - } else if (Traits::eq(*begin, plus)) { - ++ begin; - if ( begin == end ) return false; + if (begin == end) return false; } - int exp_pow_of_10 = 0; - while ( begin != end ) - { - if ( *begin < czero - || *begin >= czero + 10 - || exp_pow_of_10 * 10 < exp_pow_of_10) /* Overflows are checked lower more precisely*/ + pow_of_10_t exp_pow_of_10 = 0; + while (begin != end) { + pow_of_10_t const sub_value = *begin - czero; + + if ( *begin < czero || *begin >= czero + 10 + || ((std::numeric_limits::max)() - sub_value) / 10 < exp_pow_of_10) return false; exp_pow_of_10 *= 10; - exp_pow_of_10 += *begin - zero; + exp_pow_of_10 += sub_value; ++ begin; }; - if ( exp_pow_of_10 ) { - /* Overflows are checked lower */ - if ( exp_has_minus ) { - pow_of_10 -= exp_pow_of_10; - } else { - pow_of_10 += exp_pow_of_10; - } + if (exp_has_minus) { + if ((std::numeric_limits::min)() + exp_pow_of_10 > pow_of_10) + return false; // failed overflow check + pow_of_10 -= exp_pow_of_10; + } else { + if ((std::numeric_limits::max)() - exp_pow_of_10 < pow_of_10) + return false; // failed overflow check + pow_of_10 += exp_pow_of_10; } } /* We need a more accurate algorithm... We can not use current algorithm * with long doubles (and with doubles if sizeof(double)==sizeof(long double)). */ + typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type::wide_result_t wide_result_t; const wide_result_t result = std::pow(static_cast(10.0), pow_of_10) * mantissa; value = static_cast( has_minus ? (boost::math::changesign)(result) : result); - if ( (boost::math::isinf)(value) || (boost::math::isnan)(value) ) return false; - - return true; + return !((boost::math::isinf)(value) || (boost::math::isnan)(value)); } // Unsilence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data #if defined(_MSC_VER) && (_MSC_VER == 1400) @@ -1418,158 +1257,107 @@ namespace boost { #endif } - namespace detail // parser_buf + namespace detail // basic_unlockedbuf { - // - // class parser_buf: // acts as a stream buffer which wraps around a pair of pointers - // - // This class is copied (and slightly changed) from - // boost/regex/v4/cpp_regex_traits.hpp - // Thanks John Maddock for it! (previous version had some - // problems with libc++ and some other STL implementations) - template - class parser_buf : public BufferType { - typedef BufferType base_type; - typedef typename base_type::int_type int_type; - typedef typename base_type::char_type char_type; - typedef typename base_type::pos_type pos_type; - typedef ::std::streamsize streamsize; - typedef typename base_type::off_type off_type; - + // and gives acces to internals + template + class basic_unlockedbuf : public basic_pointerbuf { public: - parser_buf() : base_type() { setbuf(0, 0); } - const charT* getnext() { return this->gptr(); } + typedef basic_pointerbuf base_type; + typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize; + #ifndef BOOST_NO_USING_TEMPLATE using base_type::pptr; using base_type::pbase; + using base_type::setbuf; #else charT* pptr() const { return base_type::pptr(); } charT* pbase() const { return base_type::pbase(); } + BufferType* setbuf(char_type* s, streamsize n) { return base_type::setbuf(s, n); } #endif - base_type* setbuf(char_type* s, streamsize n) { - this->setg(s, s, s + n); - return this; - } - - pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) { - if(which & ::std::ios_base::out) - return pos_type(off_type(-1)); - off_type size = static_cast(this->egptr() - this->eback()); - charT* g = this->eback(); - if(off_type(sp) <= size) - { - this->setg(g, g + off_type(sp), g + size); - } - return pos_type(off_type(-1)); - } - - pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) { - typedef typename boost::int_t::least cast_type; - - if(which & ::std::ios_base::out) - return pos_type(off_type(-1)); - std::ptrdiff_t size = this->egptr() - this->eback(); - std::ptrdiff_t pos = this->gptr() - this->eback(); - charT* g = this->eback(); - switch(static_cast(way)) - { - case ::std::ios_base::beg: - if((off < 0) || (off > size)) - return pos_type(off_type(-1)); - else - this->setg(g, g + off, g + size); - break; - case ::std::ios_base::end: - if((off < 0) || (off > size)) - return pos_type(off_type(-1)); - else - this->setg(g, g + size - off, g + size); - break; - case ::std::ios_base::cur: - { - std::ptrdiff_t newpos = static_cast(pos + off); - if((newpos < 0) || (newpos > size)) - return pos_type(off_type(-1)); - else - this->setg(g, g + newpos, g + size); - break; - } - default: ; - } -#ifdef BOOST_MSVC -#pragma warning(push) -#pragma warning(disable:4244) -#endif - return static_cast(this->gptr() - this->eback()); -#ifdef BOOST_MSVC -#pragma warning(pop) -#endif - } - private: - parser_buf& operator=(const parser_buf&); - parser_buf(const parser_buf&); }; } namespace detail { struct do_not_construct_out_stream_t{}; + + template + struct out_stream_helper_trait { +#if defined(BOOST_NO_STRINGSTREAM) + typedef std::ostrstream out_stream_t; + typedef void buffer_t; +#elif defined(BOOST_NO_STD_LOCALE) + typedef std::ostringstream out_stream_t; + typedef basic_unlockedbuf buffer_t; +#else + typedef std::basic_ostringstream + out_stream_t; + typedef basic_unlockedbuf, CharT> + buffer_t; +#endif + }; } - namespace detail // optimized stream wrapper + namespace detail // optimized stream wrappers { - // String representation of Source has an upper limit. template< class CharT // a result of widest_char transformation - , class Traits // usually char_traits + , class Traits , bool RequiresStringbuffer + , std::size_t CharacterBufferSize > - class lexical_stream_limited_src - { + class lexical_istream_limited_src: boost::noncopyable { + typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait::buffer_t + buffer_t; -#if defined(BOOST_NO_STRINGSTREAM) - typedef std::ostrstream out_stream_t; -#elif defined(BOOST_NO_STD_LOCALE) - typedef std::ostringstream out_stream_t; - typedef parser_buf buffer_t; -#else - typedef std::basic_ostringstream out_stream_t; - typedef parser_buf, CharT> buffer_t; -#endif + typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait::out_stream_t + out_stream_t; + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< RequiresStringbuffer, out_stream_t, do_not_construct_out_stream_t >::type deduced_out_stream_t; - // A string representation of Source is written to [start, finish). - CharT* start; - CharT* finish; + // A string representation of Source is written to `buffer`. deduced_out_stream_t out_stream; + CharT buffer[CharacterBufferSize]; + + // After the `operator <<` finishes, `[start, finish)` is + // the range to output by `operator >>` + const CharT* start; + const CharT* finish; public: - lexical_stream_limited_src(CharT* sta, CharT* fin) BOOST_NOEXCEPT - : start(sta) - , finish(fin) + lexical_istream_limited_src() BOOST_NOEXCEPT + : start(buffer) + , finish(buffer + CharacterBufferSize) {} + + const CharT* cbegin() const BOOST_NOEXCEPT { + return start; + } + + const CharT* cend() const BOOST_NOEXCEPT { + return finish; + } private: // Undefined: - lexical_stream_limited_src(lexical_stream_limited_src const&); - void operator=(lexical_stream_limited_src const&); + lexical_istream_limited_src(lexical_istream_limited_src const&); + void operator=(lexical_istream_limited_src const&); /************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/ - bool shl_char(CharT ch) BOOST_NOEXCEPT - { - Traits::assign(*start, ch); + bool shl_char(CharT ch) BOOST_NOEXCEPT { + Traits::assign(buffer[0], ch); finish = start + 1; return true; } #ifndef BOOST_LCAST_NO_WCHAR_T template - bool shl_char(T ch) - { + bool shl_char(T ch) { BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) , "boost::lexical_cast does not support narrowing of char types." "Use boost::locale instead" ); @@ -1579,38 +1367,34 @@ namespace boost { #else CharT const w = static_cast(ch); #endif - Traits::assign(*start, w); + Traits::assign(buffer[0], w); finish = start + 1; return true; } #endif - bool shl_char_array(CharT const* str) BOOST_NOEXCEPT - { - start = const_cast(str); + bool shl_char_array(CharT const* str) BOOST_NOEXCEPT { + start = str; finish = start + Traits::length(str); return true; } template - bool shl_char_array(T const* str) - { + bool shl_char_array(T const* str) { BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)), "boost::lexical_cast does not support narrowing of char types." "Use boost::locale instead" ); return shl_input_streamable(str); } - bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT - { - start = const_cast(str); + bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT { + start = str; finish = std::find(start, start + max_size, Traits::to_char_type(0)); return true; } template - bool shl_input_streamable(InputStreamable& input) - { + bool shl_input_streamable(InputStreamable& input) { #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE) // If you have compilation error at this point, than your STL library // does not support such conversions. Try updating it. @@ -1636,167 +1420,156 @@ namespace boost { } template - inline bool shl_signed(T n) - { - start = lcast_put_unsigned(lcast_to_unsigned(n), finish); - if(n < 0) - { - --start; + inline bool shl_unsigned(const T n) { + CharT* tmp_finish = buffer + CharacterBufferSize; + start = lcast_put_unsigned(n, tmp_finish).convert(); + finish = tmp_finish; + return true; + } + + template + inline bool shl_signed(const T n) { + CharT* tmp_finish = buffer + CharacterBufferSize; + typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned::type utype; + CharT* tmp_start = lcast_put_unsigned(lcast_to_unsigned(n), tmp_finish).convert(); + if (n < 0) { + --tmp_start; CharT const minus = lcast_char_constants::minus; - Traits::assign(*start, minus); + Traits::assign(*tmp_start, minus); } + start = tmp_start; + finish = tmp_finish; return true; } template - bool shl_real_type(const T& val, SomeCharT* begin, SomeCharT*& end) - { - if (put_inf_nan(begin, end, val)) return true; + bool shl_real_type(const T& val, SomeCharT* /*begin*/) { lcast_set_precision(out_stream, &val); return shl_input_streamable(val); } - static bool shl_real_type(float val, char* begin, char*& end) - { using namespace std; - if (put_inf_nan(begin, end, val)) return true; + bool shl_real_type(float val, char* begin) { + using namespace std; const double val_as_double = val; - end = begin + + finish = start + #if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - sprintf_s(begin, end-begin, + sprintf_s(begin, CharacterBufferSize, #else sprintf(begin, #endif "%.*g", static_cast(boost::detail::lcast_get_precision()), val_as_double); - return end > begin; + return finish > start; } - static bool shl_real_type(double val, char* begin, char*& end) - { using namespace std; - if (put_inf_nan(begin, end, val)) return true; - end = begin + + bool shl_real_type(double val, char* begin) { + using namespace std; + finish = start + #if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - sprintf_s(begin, end-begin, + sprintf_s(begin, CharacterBufferSize, #else sprintf(begin, #endif "%.*g", static_cast(boost::detail::lcast_get_precision()), val); - return end > begin; + return finish > start; } #ifndef __MINGW32__ - static bool shl_real_type(long double val, char* begin, char*& end) - { using namespace std; - if (put_inf_nan(begin, end, val)) return true; - end = begin + + bool shl_real_type(long double val, char* begin) { + using namespace std; + finish = start + #if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - sprintf_s(begin, end-begin, + sprintf_s(begin, CharacterBufferSize, #else sprintf(begin, #endif "%.*Lg", static_cast(boost::detail::lcast_get_precision()), val ); - return end > begin; + return finish > start; } #endif #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__) - static bool shl_real_type(float val, wchar_t* begin, wchar_t*& end) - { using namespace std; - if (put_inf_nan(begin, end, val)) return true; + bool shl_real_type(float val, wchar_t* begin) { + using namespace std; const double val_as_double = val; - end = begin + swprintf(begin, end-begin, + finish = start + swprintf(begin, CharacterBufferSize, L"%.*g", static_cast(boost::detail::lcast_get_precision()), val_as_double ); - return end > begin; + return finish > start; } - static bool shl_real_type(double val, wchar_t* begin, wchar_t*& end) - { using namespace std; - if (put_inf_nan(begin, end, val)) return true; - end = begin + swprintf(begin, end-begin, + bool shl_real_type(double val, wchar_t* begin) { + using namespace std; + finish = start + swprintf(begin, CharacterBufferSize, L"%.*g", static_cast(boost::detail::lcast_get_precision()), val ); - return end > begin; + return finish > start; } - static bool shl_real_type(long double val, wchar_t* begin, wchar_t*& end) - { using namespace std; - if (put_inf_nan(begin, end, val)) return true; - end = begin + swprintf(begin, end-begin, + bool shl_real_type(long double val, wchar_t* begin) { + using namespace std; + finish = start + swprintf(begin, CharacterBufferSize, L"%.*Lg", static_cast(boost::detail::lcast_get_precision()), val ); - return end > begin; + return finish > start; } #endif + template + bool shl_real(T val) { + CharT* tmp_finish = buffer + CharacterBufferSize; + if (put_inf_nan(buffer, tmp_finish, val)) { + finish = tmp_finish; + return true; + } + + return shl_real_type(val, static_cast(buffer)); + } /************************************ OPERATORS << ( ... ) ********************************/ public: template - bool operator<<(std::basic_string const& str) BOOST_NOEXCEPT - { - start = const_cast(str.data()); + bool operator<<(std::basic_string const& str) BOOST_NOEXCEPT { + start = str.data(); finish = start + str.length(); return true; } template - bool operator<<(boost::container::basic_string const& str) BOOST_NOEXCEPT - { - start = const_cast(str.data()); + bool operator<<(boost::container::basic_string const& str) BOOST_NOEXCEPT { + start = str.data(); finish = start + str.length(); return true; } - bool operator<<(bool value) BOOST_NOEXCEPT - { + bool operator<<(bool value) BOOST_NOEXCEPT { CharT const czero = lcast_char_constants::zero; - Traits::assign(*start, Traits::to_char_type(czero + value)); + Traits::assign(buffer[0], Traits::to_char_type(czero + value)); finish = start + 1; return true; } - bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT - { - start = rng.begin(); - finish = rng.end(); - return true; + template + BOOST_DEDUCED_TYPENAME boost::disable_if, bool>::type + operator<<(const iterator_range& rng) BOOST_NOEXCEPT { + return (*this) << iterator_range(rng.begin(), rng.end()); } - bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT - { - start = const_cast(rng.begin()); - finish = const_cast(rng.end()); + bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT { + start = rng.begin(); + finish = rng.end(); return true; } - bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT - { - return (*this) << iterator_range( - const_cast(reinterpret_cast(rng.begin())), - const_cast(reinterpret_cast(rng.end())) + bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT { + return (*this) << iterator_range( + reinterpret_cast(rng.begin()), + reinterpret_cast(rng.end()) ); } - bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT - { - return (*this) << iterator_range( - const_cast(reinterpret_cast(rng.begin())), - const_cast(reinterpret_cast(rng.end())) - ); - } - - bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT - { - return (*this) << iterator_range( - reinterpret_cast(rng.begin()), - reinterpret_cast(rng.end()) - ); - } - - bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT - { - return (*this) << iterator_range( - reinterpret_cast(rng.begin()), - reinterpret_cast(rng.end()) + bool operator<<(const iterator_range& rng) BOOST_NOEXCEPT { + return (*this) << iterator_range( + reinterpret_cast(rng.begin()), + reinterpret_cast(rng.end()) ); } @@ -1829,114 +1602,102 @@ namespace boost { bool operator<<(short n) { return shl_signed(n); } bool operator<<(int n) { return shl_signed(n); } bool operator<<(long n) { return shl_signed(n); } - bool operator<<(unsigned short n) { start = lcast_put_unsigned(n, finish); return true; } - bool operator<<(unsigned int n) { start = lcast_put_unsigned(n, finish); return true; } - bool operator<<(unsigned long n) { start = lcast_put_unsigned(n, finish); return true; } + bool operator<<(unsigned short n) { return shl_unsigned(n); } + bool operator<<(unsigned int n) { return shl_unsigned(n); } + bool operator<<(unsigned long n) { return shl_unsigned(n); } #if defined(BOOST_HAS_LONG_LONG) - bool operator<<(boost::ulong_long_type n) { start = lcast_put_unsigned(n, finish); return true; } + bool operator<<(boost::ulong_long_type n) { return shl_unsigned(n); } bool operator<<(boost::long_long_type n) { return shl_signed(n); } #elif defined(BOOST_HAS_MS_INT64) - bool operator<<(unsigned __int64 n) { start = lcast_put_unsigned(n, finish); return true; } + bool operator<<(unsigned __int64 n) { return shl_unsigned(n); } bool operator<<( __int64 n) { return shl_signed(n); } #endif #ifdef BOOST_HAS_INT128 - bool operator<<(const boost::uint128_type& n) { start = lcast_put_unsigned(n, finish); return true; } - bool operator<<(const boost::int128_type& n) { return shl_signed(n); } + bool operator<<(const boost::uint128_type& n) { return shl_unsigned(n); } + bool operator<<(const boost::int128_type& n) { return shl_signed(n); } #endif - - bool operator<<(float val) { return shl_real_type(val, start, finish); } - bool operator<<(double val) { return shl_real_type(val, start, finish); } + bool operator<<(float val) { return shl_real(val); } + bool operator<<(double val) { return shl_real(val); } bool operator<<(long double val) { #ifndef __MINGW32__ - return shl_real_type(val, start, finish); + return shl_real(val); #else - return shl_real_type(static_cast(val), start, finish); + return shl_real(static_cast(val)); #endif } - template - bool operator<<(boost::array const& input) BOOST_NOEXCEPT - { return shl_char_array_limited(input.begin(), N); } - - template - bool operator<<(boost::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } - - template - bool operator<<(boost::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } + // Adding constness to characters. Constness does not change layout + template + BOOST_DEDUCED_TYPENAME boost::disable_if, bool>::type + operator<<(boost::array const& input) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG( + (sizeof(boost::array) == sizeof(boost::array)), + "boost::array and boost::array must have exactly the same layout." + ); + return ((*this) << reinterpret_cast const& >(input)); + } template - bool operator<<(boost::array const& input) BOOST_NOEXCEPT - { return shl_char_array_limited(input.begin(), N); } + bool operator<<(boost::array const& input) BOOST_NOEXCEPT { + return shl_char_array_limited(input.begin(), N); + } template - bool operator<<(boost::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } + bool operator<<(boost::array const& input) BOOST_NOEXCEPT { + return ((*this) << reinterpret_cast const& >(input)); + } template - bool operator<<(boost::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } + bool operator<<(boost::array const& input) BOOST_NOEXCEPT { + return ((*this) << reinterpret_cast const& >(input)); + } #ifndef BOOST_NO_CXX11_HDR_ARRAY - template - bool operator<<(std::array const& input) BOOST_NOEXCEPT - { - if (input.size()) return shl_char_array_limited(&input[0], N); - else return true; - } - - template - bool operator<<(std::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } - - template - bool operator<<(std::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } - - template - bool operator<<(std::array const& input) BOOST_NOEXCEPT - { - if (input.size()) return shl_char_array_limited(&input[0], N); - else return true; + // Making a Boost.Array from std::array + template + bool operator<<(std::array const& input) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG( + (sizeof(std::array) == sizeof(boost::array)), + "std::array and boost::array must have exactly the same layout. " + "Bug in implementation of std::array or boost::array." + ); + return ((*this) << reinterpret_cast const& >(input)); } - - template - bool operator<<(std::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } - - template - bool operator<<(std::array const& input) BOOST_NOEXCEPT - { return ((*this) << reinterpret_cast const& >(input)); } #endif - template bool operator<<(const InStreamable& input) { return shl_input_streamable(input); } + }; + + + template + class lexical_ostream_limited_src: boost::noncopyable { + //`[start, finish)` is the range to output by `operator >>` + const CharT* start; + const CharT* const finish; + + public: + lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT + : start(begin) + , finish(end) + {} /************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/ private: - template - bool shr_unsigned(Type& output) - { + bool shr_unsigned(Type& output) { if (start == finish) return false; CharT const minus = lcast_char_constants::minus; CharT const plus = lcast_char_constants::plus; - bool has_minus = false; + bool const has_minus = Traits::eq(minus, *start); /* We won`t use `start' any more, so no need in decrementing it after */ - if ( Traits::eq(minus,*start) ) - { - ++start; - has_minus = true; - } else if ( Traits::eq( plus, *start ) ) - { + if (has_minus || Traits::eq(plus, *start)) { ++start; } - bool const succeed = lcast_ret_unsigned(output, start, finish); + bool const succeed = lcast_ret_unsigned(output, start, finish).convert(); if (has_minus) { output = static_cast(0u - output); @@ -1946,26 +1707,20 @@ namespace boost { } template - bool shr_signed(Type& output) - { + bool shr_signed(Type& output) { if (start == finish) return false; CharT const minus = lcast_char_constants::minus; CharT const plus = lcast_char_constants::plus; typedef BOOST_DEDUCED_TYPENAME make_unsigned::type utype; - utype out_tmp =0; - bool has_minus = false; + utype out_tmp = 0; + bool const has_minus = Traits::eq(minus, *start); /* We won`t use `start' any more, so no need in decrementing it after */ - if ( Traits::eq(minus,*start) ) - { - ++start; - has_minus = true; - } else if ( Traits::eq(plus, *start) ) - { + if (has_minus || Traits::eq(plus, *start)) { ++start; } - bool succeed = lcast_ret_unsigned(out_tmp, start, finish); + bool succeed = lcast_ret_unsigned(out_tmp, start, finish).convert(); if (has_minus) { utype const comp_val = (static_cast(1) << std::numeric_limits::digits); succeed = succeed && out_tmp<=comp_val; @@ -1973,7 +1728,7 @@ namespace boost { } else { utype const comp_val = static_cast((std::numeric_limits::max)()); succeed = succeed && out_tmp<=comp_val; - output = out_tmp; + output = static_cast(out_tmp); } return succeed; } @@ -1992,13 +1747,17 @@ namespace boost { "support such conversions. Try updating it." ); #endif + typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait::buffer_t + buffer_t; #if defined(BOOST_NO_STRINGSTREAM) std::istrstream stream(start, finish - start); #else buffer_t buf; - buf.setbuf(start, finish - start); + // Usually `istream` and `basic_istream` do not modify + // content of buffer; `buffer_t` assures that this is true + buf.setbuf(const_cast(start), finish - start); #if defined(BOOST_NO_STD_LOCALE) std::istream stream(&buf); #else @@ -2013,17 +1772,8 @@ namespace boost { stream.unsetf(std::ios::skipws); lcast_set_precision(stream, static_cast(0)); - return stream >> output && - stream.get() == -#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING) - // GCC 2.9x lacks std::char_traits<>::eof(). - // We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3 - // configurations, which do provide std::char_traits<>::eof(). - - EOF; -#else - Traits::eof(); -#endif + return (stream >> output) + && (stream.get() == Traits::eof()); #ifndef BOOST_NO_EXCEPTIONS } catch (const ::std::ios_base::failure& /*f*/) { @@ -2033,8 +1783,7 @@ namespace boost { } template - inline bool shr_xchar(T& output) - { + inline bool shr_xchar(T& output) BOOST_NOEXCEPT { BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ), "boost::lexical_cast does not support narrowing of character types." "Use boost::locale instead" ); @@ -2047,6 +1796,19 @@ namespace boost { return ok; } + template + bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT { + using namespace std; + const std::size_t size = static_cast(finish - start); + if (size > N - 1) { // `-1` because we need to store \0 at the end + return false; + } + + memcpy(&output[0], start, size * sizeof(CharT)); + output[size] = Traits::to_char_type(0); + return true; + } + /************************************ OPERATORS >> ( ... ) ********************************/ public: bool operator>>(unsigned short& output) { return shr_unsigned(output); } @@ -2081,100 +1843,72 @@ namespace boost { bool operator>>(char32_t& output) { return shr_xchar(output); } #endif template - bool operator>>(std::basic_string& str) { str.assign(start, finish); return true; } + bool operator>>(std::basic_string& str) { + str.assign(start, finish); return true; + } template - bool operator>>(boost::container::basic_string& str) { str.assign(start, finish); return true; } - - - private: - template - bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT - { - using namespace std; - const std::size_t size = finish - start; - if (size > N - 1) { // `-1` because we need to store \0 at the end - return false; - } - - memcpy(&output[0], start, size * sizeof(CharT)); - output[size] = Traits::to_char_type(0); - return true; + bool operator>>(boost::container::basic_string& str) { + str.assign(start, finish); return true; } - public: - template - bool operator>>(boost::array& output) BOOST_NOEXCEPT - { + bool operator>>(boost::array& output) BOOST_NOEXCEPT { return shr_std_array(output); } template - bool operator>>(boost::array& output) - { + bool operator>>(boost::array& output) BOOST_NOEXCEPT { return ((*this) >> reinterpret_cast& >(output)); } template - bool operator>>(boost::array& output) - { + bool operator>>(boost::array& output) BOOST_NOEXCEPT { return ((*this) >> reinterpret_cast& >(output)); } #ifndef BOOST_NO_CXX11_HDR_ARRAY - template - bool operator>>(std::array& output) BOOST_NOEXCEPT - { - return shr_std_array(output); - } - - template - bool operator>>(std::array& output) - { - return ((*this) >> reinterpret_cast& >(output)); - } - - template - bool operator>>(std::array& output) - { - return ((*this) >> reinterpret_cast& >(output)); + template + bool operator>>(std::array& output) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG( + (sizeof(boost::array) == sizeof(boost::array)), + "std::array and boost::array must have exactly the same layout." + ); + return ((*this) >> reinterpret_cast& >(output)); } #endif + bool operator>>(bool& output) BOOST_NOEXCEPT { + output = false; // Suppress warning about uninitalized variable - /* - * case "-0" || "0" || "+0" : output = false; return true; - * case "1" || "+1": output = true; return true; - * default: return false; - */ - bool operator>>(bool& output) BOOST_NOEXCEPT - { + if (start == finish) return false; CharT const zero = lcast_char_constants::zero; CharT const plus = lcast_char_constants::plus; CharT const minus = lcast_char_constants::minus; - switch(finish-start) - { - case 1: - output = Traits::eq(start[0], zero+1); - return output || Traits::eq(start[0], zero ); - case 2: - if ( Traits::eq( plus, *start) ) - { - ++start; - output = Traits::eq(start[0], zero +1); - return output || Traits::eq(start[0], zero ); - } else - { - output = false; - return Traits::eq( minus, *start) - && Traits::eq( zero, start[1]); - } - default: - output = false; // Suppress warning about uninitalized variable - return false; + const CharT* const dec_finish = finish - 1; + output = Traits::eq(*dec_finish, zero + 1); + if (!output && !Traits::eq(*dec_finish, zero)) { + return false; // Does not ends on '0' or '1' + } + + if (start == dec_finish) return true; + + // We may have sign at the beginning + if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) { + ++ start; + } + + // Skipping zeros + while (start != dec_finish) { + if (!Traits::eq(zero, *start)) { + return false; // Not a zero => error + } + + ++ start; } + + return true; } bool operator>>(float& output) { return lcast_ret_float(output,start,finish); } @@ -2184,7 +1918,7 @@ namespace boost { template bool float_types_converter_internal(T& output, int /*tag*/) { if (parse_inf_nan(start, finish, output)) return true; - bool return_value = shr_using_base_class(output); + bool const return_value = shr_using_base_class(output); /* Some compilers and libraries successfully * parse 'inf', 'INFINITY', '1.0E', '1.0E-'... @@ -2209,13 +1943,12 @@ namespace boost { } // Optimised converter - bool float_types_converter_internal(double& output,char /*tag*/) { - return lcast_ret_float(output,start,finish); + bool float_types_converter_internal(double& output, char /*tag*/) { + return lcast_ret_float(output, start, finish); } public: - bool operator>>(double& output) - { + bool operator>>(double& output) { /* * Some compilers implement long double as double. In that case these types have * same size, same precision, same max and min values... And it means, @@ -2235,16 +1968,17 @@ namespace boost { return float_types_converter_internal(output, tag); } - bool operator>>(long double& output) - { + bool operator>>(long double& output) { int tag = 0; return float_types_converter_internal(output, tag); } // Generic istream-based algorithm. // lcast_streambuf_for_target::value is true. - template - bool operator>>(InputStreamable& output) { return shr_using_base_class(output); } + template + bool operator>>(InputStreamable& output) { + return shr_using_base_class(output); + } }; } @@ -2252,218 +1986,221 @@ namespace boost { { template struct is_stdstring - { - BOOST_STATIC_CONSTANT(bool, value = false ); - }; + : boost::false_type + {}; template struct is_stdstring< std::basic_string > - { - BOOST_STATIC_CONSTANT(bool, value = true ); - }; + : boost::true_type + {}; template struct is_stdstring< boost::container::basic_string > - { - BOOST_STATIC_CONSTANT(bool, value = true ); - }; + : boost::true_type + {}; template struct is_arithmetic_and_not_xchars { - BOOST_STATIC_CONSTANT(bool, value = - ( - boost::type_traits::ice_and< - boost::is_arithmetic::value, - boost::is_arithmetic::value, - boost::type_traits::ice_not< - detail::is_char_or_wchar::value - >::value, - boost::type_traits::ice_not< - detail::is_char_or_wchar::value - >::value - >::value - ) - ); + BOOST_STATIC_CONSTANT(bool, value = ( + boost::type_traits::ice_and< + boost::type_traits::ice_not< + boost::detail::is_character::value + >::value, + boost::type_traits::ice_not< + boost::detail::is_character::value + >::value, + boost::is_arithmetic::value, + boost::is_arithmetic::value + >::value + )); }; /* - * is_xchar_to_xchar::value is true, when - * Target and Souce are the same char types, or when - * Target and Souce are char types of the same size. + * is_xchar_to_xchar::value is true, + * Target and Souce are char types of the same size 1 (char, signed char, unsigned char). */ template - struct is_xchar_to_xchar + struct is_xchar_to_xchar { - BOOST_STATIC_CONSTANT(bool, value = - ( - boost::type_traits::ice_or< - boost::type_traits::ice_and< - is_same::value, - is_char_or_wchar::value - >::value, - boost::type_traits::ice_and< - boost::type_traits::ice_eq< sizeof(char),sizeof(Target)>::value, - boost::type_traits::ice_eq< sizeof(char),sizeof(Source)>::value, - is_char_or_wchar::value, - is_char_or_wchar::value - >::value - >::value - ) - ); + BOOST_STATIC_CONSTANT(bool, value = ( + boost::type_traits::ice_and< + boost::type_traits::ice_eq::value, + boost::type_traits::ice_eq::value, + boost::detail::is_character::value, + boost::detail::is_character::value + >::value + )); }; template struct is_char_array_to_stdstring - { - BOOST_STATIC_CONSTANT(bool, value = false ); - }; + : boost::false_type + {}; template struct is_char_array_to_stdstring< std::basic_string, CharT* > - { - BOOST_STATIC_CONSTANT(bool, value = true ); - }; + : boost::true_type + {}; template struct is_char_array_to_stdstring< std::basic_string, const CharT* > - { - BOOST_STATIC_CONSTANT(bool, value = true ); - }; + : boost::true_type + {}; template struct is_char_array_to_stdstring< boost::container::basic_string, CharT* > - { - BOOST_STATIC_CONSTANT(bool, value = true ); - }; + : boost::true_type + {}; template struct is_char_array_to_stdstring< boost::container::basic_string, const CharT* > - { - BOOST_STATIC_CONSTANT(bool, value = true ); - }; + : boost::true_type + {}; -#if (defined _MSC_VER) -# pragma warning( push ) -# pragma warning( disable : 4701 ) // possible use of ... before initialization -# pragma warning( disable : 4702 ) // unreachable code -# pragma warning( disable : 4267 ) // conversion from 'size_t' to 'unsigned int' -#endif template - struct lexical_cast_do_cast + struct lexical_converter_impl { - static inline Target lexical_cast_impl(const Source& arg) - { - typedef lexical_cast_stream_traits stream_trait; - - typedef detail::lexical_stream_limited_src< - BOOST_DEDUCED_TYPENAME stream_trait::char_type, - BOOST_DEDUCED_TYPENAME stream_trait::traits, - stream_trait::requires_stringbuf - > interpreter_type; + typedef lexical_cast_stream_traits stream_trait; - // Target type must be default constructible - Target result; + typedef detail::lexical_istream_limited_src< + BOOST_DEDUCED_TYPENAME stream_trait::char_type, + BOOST_DEDUCED_TYPENAME stream_trait::traits, + stream_trait::requires_stringbuf, + stream_trait::len_t::value + 1 + > i_interpreter_type; - BOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1]; - stream_trait::len_t::check_coverage(); + typedef detail::lexical_ostream_limited_src< + BOOST_DEDUCED_TYPENAME stream_trait::char_type, + BOOST_DEDUCED_TYPENAME stream_trait::traits + > o_interpreter_type; - interpreter_type interpreter(buf, buf + stream_trait::len_t::value + 1); + static inline bool try_convert(const Source& arg, Target& result) { + i_interpreter_type i_interpreter; // Disabling ADL, by directly specifying operators. - if(!(interpreter.operator <<(arg) && interpreter.operator >>(result))) - BOOST_LCAST_THROW_BAD_CAST(Source, Target); + if (!(i_interpreter.operator <<(arg))) + return false; - return result; + o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend()); + + // Disabling ADL, by directly specifying operators. + if(!(out.operator >>(result))) + return false; + + return true; } }; -#if (defined _MSC_VER) -# pragma warning( pop ) -#endif - template - struct lexical_cast_copy + template + struct copy_converter_impl { - static inline const Source& lexical_cast_impl(const Source &arg) BOOST_NOEXCEPT - { - return arg; +// MSVC fail to forward an array (DevDiv#555157 "SILENT BAD CODEGEN triggered by perfect forwarding", +// fixed in 2013 RTM). +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined(BOOST_MSVC) || BOOST_MSVC >= 1800) + template + static inline bool try_convert(T&& arg, Target& result) { + result = static_cast(arg); // eqaul to `result = std::forward(arg);` + return true; + } +#else + static inline bool try_convert(const Source& arg, Target& result) { + result = arg; + return true; } +#endif }; - template + template struct detect_precision_loss { - typedef boost::numeric::Trunc Rounder; - typedef Source source_type ; + typedef Source source_type; + typedef boost::numeric::Trunc Rounder; + typedef BOOST_DEDUCED_TYPENAME mpl::if_< + boost::is_arithmetic, Source, Source const& + >::type argument_type ; - typedef BOOST_DEDUCED_TYPENAME mpl::if_< - boost::is_arithmetic, Source, Source const& - >::type argument_type ; + static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT { + const source_type near_int = Rounder::nearbyint(s); + if (near_int && is_ok) { + const source_type orig_div_round = s / near_int; + const source_type eps = std::numeric_limits::epsilon(); - static source_type nearbyint ( argument_type s ) - { - const source_type near_int = Rounder::nearbyint(s); - if (near_int) { - const source_type orig_div_round = s / near_int; - const source_type eps = std::numeric_limits::epsilon(); + is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps); + } - if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps) - BOOST_LCAST_THROW_BAD_CAST(Source, Target); + return s; } - return s ; - } + typedef typename Rounder::round_style round_style; + }; - typedef typename Rounder::round_style round_style; - } ; + template + struct fake_precision_loss: public Base + { + typedef Source source_type ; + typedef BOOST_DEDUCED_TYPENAME mpl::if_< + boost::is_arithmetic, Source, Source const& + >::type argument_type ; + + static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT { + return s; + } + }; - template struct nothrow_overflow_handler { - void operator() ( boost::numeric::range_check_result r ) - { - if (r != boost::numeric::cInRange) - BOOST_LCAST_THROW_BAD_CAST(Source, Target); - } - } ; + inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT { + return (r == boost::numeric::cInRange); + } + }; + + template + inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT { + typedef boost::numeric::converter< + Target, + Source, + boost::numeric::conversion_traits, + nothrow_overflow_handler, + detect_precision_loss + > converter_orig_t; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + boost::is_base_of< detect_precision_loss, converter_orig_t >::value, + converter_orig_t, + fake_precision_loss + >::type converter_t; + + bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg)); + result = converter_t::low_level_convert(converter_t::nearbyint(arg, res)); + return res; + } template struct lexical_cast_dynamic_num_not_ignoring_minus { - static inline Target lexical_cast_impl(const Source &arg) - { - return boost::numeric::converter< - Target, - Source, - boost::numeric::conversion_traits, - nothrow_overflow_handler, - detect_precision_loss - >::convert(arg); + static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { + return noexcept_numeric_convert(arg, result); } }; template struct lexical_cast_dynamic_num_ignoring_minus { - static inline Target lexical_cast_impl(const Source &arg) - { + static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c< boost::is_float::value, boost::mpl::identity, boost::make_unsigned >::type usource_t; - - typedef boost::numeric::converter< - Target, - usource_t, - boost::numeric::conversion_traits, - nothrow_overflow_handler, - detect_precision_loss - > converter_t; - - return ( - arg < 0 ? static_cast(0u - converter_t::convert(0u - arg)) : converter_t::convert(arg) - ); + + if (arg < 0) { + const bool res = noexcept_numeric_convert(0u - arg, result); + result = static_cast(0u - result); + return res; + } else { + return noexcept_numeric_convert(arg, result); + } } }; @@ -2486,12 +2223,12 @@ namespace boost { * and the result will be the two's complement. */ template - struct lexical_cast_dynamic_num + struct dynamic_num_converter_impl { - static inline Target lexical_cast_impl(const Source &arg) - { + static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< boost::type_traits::ice_and< + boost::is_unsigned::value, boost::type_traits::ice_or< boost::is_signed::value, boost::is_float::value @@ -2501,64 +2238,102 @@ namespace boost { >::value, boost::type_traits::ice_not< boost::is_same::value - >::value, - boost::is_unsigned::value + >::value >::value, lexical_cast_dynamic_num_ignoring_minus, lexical_cast_dynamic_num_not_ignoring_minus >::type caster_type; - return caster_type::lexical_cast_impl(arg); + return caster_type::try_convert(arg, result); } }; } - template - inline Target lexical_cast(const Source &arg) - { - typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay::type src; + namespace conversion { namespace detail { + + template + inline bool try_lexical_convert(const Source& arg, Target& result) + { + typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay::type src; - typedef BOOST_DEDUCED_TYPENAME boost::type_traits::ice_or< + typedef BOOST_DEDUCED_TYPENAME boost::type_traits::ice_or< boost::detail::is_xchar_to_xchar::value, boost::detail::is_char_array_to_stdstring::value, boost::type_traits::ice_and< boost::is_same::value, boost::detail::is_stdstring::value + >::value, + boost::type_traits::ice_and< + boost::is_same::value, + boost::detail::is_character::value >::value - > shall_we_copy_t; + > shall_we_copy_t; - typedef BOOST_DEDUCED_TYPENAME - boost::detail::is_arithmetic_and_not_xchars shall_we_copy_with_dynamic_check_t; + typedef boost::detail::is_arithmetic_and_not_xchars + shall_we_copy_with_dynamic_check_t; - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - shall_we_copy_t::value, - boost::detail::lexical_cast_copy, - BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - shall_we_copy_with_dynamic_check_t::value, - boost::detail::lexical_cast_dynamic_num, - boost::detail::lexical_cast_do_cast - >::type - >::type caster_type; + // We do evaluate second `if_` lazily to avoid unnecessary instantiations + // of `shall_we_copy_with_dynamic_check_t` and improve compilation times. + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + shall_we_copy_t::value, + boost::mpl::identity >, + boost::mpl::if_< + shall_we_copy_with_dynamic_check_t, + boost::detail::dynamic_num_converter_impl, + boost::detail::lexical_converter_impl + > + >::type caster_type_lazy; + + typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type; + + return caster_type::try_convert(arg, result); + } - return caster_type::lexical_cast_impl(arg); + template + inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result) + { + BOOST_STATIC_ASSERT_MSG( + boost::detail::is_character::value, + "This overload of try_lexical_convert is meant to be used only with arrays of characters." + ); + return ::boost::conversion::detail::try_lexical_convert( + ::boost::iterator_range(chars, chars + count), result + ); + } + + }} // namespace conversion::detail + + namespace conversion { + // ADL barrier + using ::boost::conversion::detail::try_lexical_convert; + } + + template + inline Target lexical_cast(const Source &arg) + { + Target result; + + if (!boost::conversion::detail::try_lexical_convert(arg, result)) + BOOST_LCAST_THROW_BAD_CAST(Source, Target); + + return result; } template inline Target lexical_cast(const char* chars, std::size_t count) - { + { return ::boost::lexical_cast( ::boost::iterator_range(chars, chars + count) ); } - template inline Target lexical_cast(const unsigned char* chars, std::size_t count) { - return ::boost::lexical_cast( + return ::boost::lexical_cast( ::boost::iterator_range(chars, chars + count) - ); - } + ); + } template inline Target lexical_cast(const signed char* chars, std::size_t count) @@ -2598,7 +2373,7 @@ namespace boost { } // namespace boost -#else // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#else namespace boost { namespace detail @@ -2671,16 +2446,7 @@ namespace boost { { return !is_pointer::value && stream >> output && - stream.get() == -#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING) -// GCC 2.9x lacks std::char_traits<>::eof(). -// We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3 -// configurations, which do provide std::char_traits<>::eof(). - - EOF; -#else - traits_type::eof(); -#endif + stream.get() == traits_type::eof(); } bool operator>>(std::string &output) @@ -2735,7 +2501,7 @@ namespace boost { // Copyright Kevlin Henney, 2000-2005. // Copyright Alexander Nasonov, 2006-2010. -// Copyright Antony Polukhin, 2011-2013. +// Copyright Antony Polukhin, 2011-2014. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at diff --git a/src/thirdparty/boost_lib/boost/make_unique.hpp b/src/thirdparty/boost_lib/boost/make_unique.hpp new file mode 100644 index 000000000..c163673c6 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/make_unique.hpp @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_MAKE_UNIQUE_HPP_INCLUDED +#define BOOST_MAKE_UNIQUE_HPP_INCLUDED + +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/memory_order.hpp b/src/thirdparty/boost_lib/boost/memory_order.hpp index 4945af623..fbe903442 100644 --- a/src/thirdparty/boost_lib/boost/memory_order.hpp +++ b/src/thirdparty/boost_lib/boost/memory_order.hpp @@ -37,15 +37,19 @@ namespace boost // // if( mo & ( memory_order_acquire | memory_order_consume ) ) { ...fence... } // +// The values are also in the order of increasing "strength" +// of the fences so that success/failure orders can be checked +// efficiently in compare_exchange methods. +// enum memory_order { memory_order_relaxed = 0, - memory_order_acquire = 1, - memory_order_release = 2, - memory_order_acq_rel = 3, // acquire | release - memory_order_seq_cst = 7, // acq_rel | 4 - memory_order_consume = 8 + memory_order_consume = 1, + memory_order_acquire = 2, + memory_order_release = 4, + memory_order_acq_rel = 6, // acquire | release + memory_order_seq_cst = 14 // acq_rel | 8 }; } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/move/core.hpp b/src/thirdparty/boost_lib/boost/move/core.hpp index 9586ecada..0efa2af6d 100644 --- a/src/thirdparty/boost_lib/boost/move/core.hpp +++ b/src/thirdparty/boost_lib/boost/move/core.hpp @@ -168,6 +168,46 @@ const ::boost::rv< TYPE >& \ // + namespace boost { + namespace move_detail { + + template + inline typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_lvalue_reference::value || + !::boost::has_move_emulation_enabled::value + , T&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference::value && + ::boost::has_move_emulation_enabled::value + , ::boost::rv&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return *static_cast< ::boost::rv* >(::boost::move_detail::addressof(x)); + } + + template + inline typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference::value && + ::boost::has_move_emulation_enabled::value + , ::boost::rv&>::type + move_return(::boost::rv& x) BOOST_NOEXCEPT + { + return x; + } + + } //namespace move_detail { + } //namespace boost { + + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + boost::move_detail::move_return< RET_TYPE >(REF) + // + ////////////////////////////////////////////////////////////////////////////// // // BOOST_MOVABLE_BUT_NOT_COPYABLE @@ -220,9 +260,12 @@ #elif defined(_MSC_VER) && (_MSC_VER == 1600) //Standard rvalue binding rules but with some bugs #define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG + #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG //Use standard library for MSVC to avoid namespace issues as //some move calls in the STL are not fully qualified. //#define BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE + #elif defined(_MSC_VER) && (_MSC_VER == 1700) + #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG #endif #endif @@ -269,8 +312,8 @@ //!This macro is used to achieve portable syntax in move //!constructors and assignments for template classes marked as //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE. - //!As macros have problems with comma-separatd template arguments, - //!the template argument must be preceded with BOOST_RV_REF_START + //!As macros have problems with comma-separated template arguments, + //!the template argument must be preceded with BOOST_RV_REF_BEG //!and ended with BOOST_RV_REF_END #define BOOST_RV_REF_BEG\ \ @@ -279,8 +322,8 @@ //!This macro is used to achieve portable syntax in move //!constructors and assignments for template classes marked as //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE. - //!As macros have problems with comma-separatd template arguments, - //!the template argument must be preceded with BOOST_RV_REF_START + //!As macros have problems with comma-separated template arguments, + //!the template argument must be preceded with BOOST_RV_REF_BEG //!and ended with BOOST_RV_REF_END #define BOOST_RV_REF_END\ && \ @@ -298,7 +341,6 @@ // #if !defined(BOOST_MOVE_DOXYGEN_INVOKED) - /// @cond #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ TYPE && \ @@ -328,10 +370,69 @@ const TYPE & \ // - /// @endcond #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + #if !defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + //!This macro is used to achieve portable move return semantics. + //!The Standard allows implicit move returns when the object to be returned + //!is designated by an lvalue and: + //! - The criteria for elision of a copy operation are met OR + //! - The criteria would be met save for the fact that the source object is a function parameter + //! + //!For C++11 conforming compilers this macros only yields to REF: + //! return BOOST_MOVE_RET(RET_TYPE, REF); -> return REF; + //! + //!For compilers without rvalue references + //!this macro does an explicit move if the move emulation is activated + //!and the return type (RET_TYPE) is not a reference. + //! + //!For non-conforming compilers with rvalue references like Visual 2010 & 2012, + //!an explicit move is performed if RET_TYPE is not a reference. + //! + //! Caution: When using this macro in a non-conforming or C++03 + //!compilers, a move will be performed even if the C++11 standard does not allow it + //!(e.g. returning a static variable). The user is responsible for using this macro + //!only used to return local objects that met C++11 criteria. + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + (REF) + // + + #else //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #include + + namespace boost { + namespace move_detail { + + template + inline typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_lvalue_reference::value + , T&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference::value + , Ret && >::type + move_return(T&& t) BOOST_NOEXCEPT + { + return static_cast< Ret&& >(t); + } + + } //namespace move_detail { + } //namespace boost { + + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + boost::move_detail::move_return< RET_TYPE >(REF) + // + + #endif //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + #endif //BOOST_NO_CXX11_RVALUE_REFERENCES #include diff --git a/src/thirdparty/boost_lib/boost/move/detail/config_end.hpp b/src/thirdparty/boost_lib/boost/move/detail/config_end.hpp index c43bce0e6..5f8323177 100644 --- a/src/thirdparty/boost_lib/boost/move/detail/config_end.hpp +++ b/src/thirdparty/boost_lib/boost/move/detail/config_end.hpp @@ -9,11 +9,11 @@ ////////////////////////////////////////////////////////////////////////////// #if defined BOOST_MSVC #pragma warning (pop) - #ifdef BOOST_MOVE_DETAIL_CRT_SECURE_NO_DEPRECATE - #undef BOOST_MOVE_DETAIL_CRT_SECURE_NO_DEPRECATE + #ifdef BOOST_MOVE_CRT_SECURE_NO_DEPRECATE + #undef BOOST_MOVE_CRT_SECURE_NO_DEPRECATE #undef _CRT_SECURE_NO_DEPRECATE #endif - #ifndef BOOST_MOVE_SCL_SECURE_NO_WARNINGS + #ifdef BOOST_MOVE_SCL_SECURE_NO_WARNINGS #undef BOOST_MOVE_SCL_SECURE_NO_WARNINGS #undef _SCL_SECURE_NO_WARNINGS #endif diff --git a/src/thirdparty/boost_lib/boost/move/detail/meta_utils.hpp b/src/thirdparty/boost_lib/boost/move/detail/meta_utils.hpp index 2bdb654aa..0da3c6845 100644 --- a/src/thirdparty/boost_lib/boost/move/detail/meta_utils.hpp +++ b/src/thirdparty/boost_lib/boost/move/detail/meta_utils.hpp @@ -72,19 +72,32 @@ struct identity typedef T type; }; -//is_convertible +#if defined(_MSC_VER) && (_MSC_VER >= 1400) + +//use intrinsic since in MSVC +//overaligned types can't go through ellipsis +template +struct is_convertible +{ + static const bool value = __is_convertible_to(T, U); +}; + +#else + template class is_convertible { typedef char true_t; class false_t { char dummy[2]; }; - static true_t dispatch(U); static false_t dispatch(...); + static true_t dispatch(U); static T &trigger(); public: - enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) }; + static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); }; +#endif + //and_ not_ template > struct and_ diff --git a/src/thirdparty/boost_lib/boost/mpl/O1_size.hpp b/src/thirdparty/boost_lib/boost/mpl/O1_size.hpp index 8baaa79be..98bd3a745 100644 --- a/src/thirdparty/boost_lib/boost/mpl/O1_size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/O1_size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/O1_size_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/O1_size_fwd.hpp index d97538277..c84a7a56a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/O1_size_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/O1_size_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: O1_size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/accumulate.hpp b/src/thirdparty/boost_lib/boost/mpl/accumulate.hpp index 23b76c806..dc2c75ecb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/accumulate.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/accumulate.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: accumulate.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/advance.hpp b/src/thirdparty/boost_lib/boost/mpl/advance.hpp index d811a8091..1af600417 100644 --- a/src/thirdparty/boost_lib/boost/mpl/advance.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/advance.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: advance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/advance_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/advance_fwd.hpp index 08ba5fc40..803841019 100644 --- a/src/thirdparty/boost_lib/boost/mpl/advance_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/advance_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: advance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/alias.hpp b/src/thirdparty/boost_lib/boost/mpl/alias.hpp index ff7b7bd10..f0fe0caf4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/alias.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/alias.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: alias.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace { namespace mpl = boost::mpl; diff --git a/src/thirdparty/boost_lib/boost/mpl/always.hpp b/src/thirdparty/boost_lib/boost/mpl/always.hpp index 5094b3ee9..5fe71321e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/always.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/always.hpp @@ -10,11 +10,11 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: always.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ -#include +#include #include #include @@ -23,8 +23,7 @@ namespace boost { namespace mpl { template< typename Value > struct always { template< - typename T - BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(1, typename T, na) + BOOST_MPL_PP_DEFAULT_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, typename T, na) > struct apply { @@ -32,7 +31,7 @@ template< typename Value > struct always }; }; -BOOST_MPL_AUX_ARITY_SPEC(1, always) +BOOST_MPL_AUX_ARITY_SPEC(0, always) }} diff --git a/src/thirdparty/boost_lib/boost/mpl/and.hpp b/src/thirdparty/boost_lib/boost/mpl/and.hpp index da257c8fc..454aaf2e9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/and.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/and.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: and.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include @@ -28,7 +28,7 @@ // 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)' // has to be checked in a separate condition, otherwise GCC complains // about 'and' being an alternative token -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(and) # pragma push_macro("and") @@ -41,7 +41,7 @@ # define BOOST_MPL_PREPROCESSED_HEADER and.hpp # include -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(and) # pragma pop_macro("and") diff --git a/src/thirdparty/boost_lib/boost/mpl/apply.hpp b/src/thirdparty/boost_lib/boost/mpl/apply.hpp index b0455bc06..581eb6810 100644 --- a/src/thirdparty/boost_lib/boost/mpl/apply.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/apply.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/apply_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/apply_fwd.hpp index 8cbdfaf97..5f5fa7891 100644 --- a/src/thirdparty/boost_lib/boost/mpl/apply_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/apply_fwd.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: apply_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/apply_wrap.hpp b/src/thirdparty/boost_lib/boost/mpl/apply_wrap.hpp index 5c5c6df60..b807779cf 100644 --- a/src/thirdparty/boost_lib/boost/mpl/apply_wrap.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/apply_wrap.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: apply_wrap.hpp 49272 2008-10-11 06:50:46Z agurtovoy $ -// $Date: 2008-10-10 23:50:46 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49272 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/arg.hpp b/src/thirdparty/boost_lib/boost/mpl/arg.hpp index c323a1a6e..f51adfaea 100644 --- a/src/thirdparty/boost_lib/boost/mpl/arg.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/arg.hpp @@ -15,9 +15,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/arg_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/arg_fwd.hpp index f79e0561c..7346dc355 100644 --- a/src/thirdparty/boost_lib/boost/mpl/arg_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/arg_fwd.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arg_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/arithmetic.hpp b/src/thirdparty/boost_lib/boost/mpl/arithmetic.hpp index 0384042d5..7729fd292 100644 --- a/src/thirdparty/boost_lib/boost/mpl/arithmetic.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/arithmetic.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arithmetic.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/as_sequence.hpp b/src/thirdparty/boost_lib/boost/mpl/as_sequence.hpp index 9fb5af3d4..7e671b0fd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/as_sequence.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/as_sequence.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: as_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/assert.hpp b/src/thirdparty/boost_lib/boost/mpl/assert.hpp index 7a5818e9e..4d860a4ca 100644 --- a/src/thirdparty/boost_lib/boost/mpl/assert.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/assert.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: assert.hpp 86514 2013-10-29 13:15:03Z bemandawes $ -// $Date: 2013-10-29 06:15:03 -0700 (Tue, 29 Oct 2013) $ -// $Revision: 86514 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -55,7 +56,7 @@ // and GCC (which issues "unused variable" warnings when static constants are used // at a function scope) #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ - || (BOOST_MPL_CFG_GCC != 0) + || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0) # define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr } #else # define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr) diff --git a/src/thirdparty/boost_lib/boost/mpl/at.hpp b/src/thirdparty/boost_lib/boost/mpl/at.hpp index d247d71ad..aa90e59c1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/at.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/at.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/at_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/at_fwd.hpp index a4825f0d5..6aaae3835 100644 --- a/src/thirdparty/boost_lib/boost/mpl/at_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/at_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: at_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/O1_size_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/O1_size_impl.hpp index 614730dff..3bcbd0f78 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/O1_size_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/O1_size_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: O1_size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/adl_barrier.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/adl_barrier.hpp index 077f46fc0..3968c242a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/adl_barrier.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/adl_barrier.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: adl_barrier.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/advance_backward.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/advance_backward.hpp index d44c59f8e..df5679321 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/advance_backward.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/advance_backward.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: advance_backward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/advance_forward.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/advance_forward.hpp index 4edd3ead7..62b0101c6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/advance_forward.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/advance_forward.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: advance_forward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/apply_1st.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/apply_1st.hpp index 0620215ae..b5677482b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/apply_1st.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/apply_1st.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: apply_1st.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/arg_typedef.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/arg_typedef.hpp index ed5e5bd72..362db1600 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/arg_typedef.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/arg_typedef.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arg_typedef.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/arithmetic_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/arithmetic_op.hpp index 0a310b7ce..0171db5db 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/arithmetic_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/arithmetic_op.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arithmetic_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/arity.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/arity.hpp index adedcc6b5..d13ab4ade 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/arity.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/arity.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/arity_spec.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/arity_spec.hpp index 6ae5cc72b..7c8221428 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/arity_spec.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/arity_spec.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arity_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/at_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/at_impl.hpp index 4af7cfed8..923937480 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/at_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/at_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/back_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/back_impl.hpp index 3b7e4a9e5..a3c7248df 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/back_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/back_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: back_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/basic_bind.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/basic_bind.hpp index 90cac01e8..6c1f64344 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/basic_bind.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/basic_bind.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: basic_bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/begin_end_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/begin_end_impl.hpp index 1a220a24a..58b70dd10 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/begin_end_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/begin_end_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/clear_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/clear_impl.hpp index 3850086ca..20b270c0c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/clear_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/clear_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/common_name_wknd.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/common_name_wknd.hpp index a6c7898b2..00758b243 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/common_name_wknd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/common_name_wknd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: common_name_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/comparison_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/comparison_op.hpp index f0850a4d0..2df72d300 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/comparison_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/comparison_op.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: comparison_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/adl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/adl.hpp index d6ead717e..e9bdf1156 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/adl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/adl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: adl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/arrays.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/arrays.hpp index d801cf7c3..a9ea68ad6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/arrays.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/arrays.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arrays.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/bcc.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/bcc.hpp index f4817ca62..fe4941a59 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/bcc.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/bcc.hpp @@ -10,7 +10,7 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bcc.hpp 49272 2008-10-11 06:50:46Z agurtovoy $ +// $Id$ // $Date: 2004-09-02 10:41:37 -0500 (Thu, 02 Sep 2004) $ // $Revision: 24874 $ diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/bind.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/bind.hpp index 02a781420..10bcb94b8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/bind.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/bind.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/compiler.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/compiler.hpp index e80ccde7f..7d3e3b662 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/compiler.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/compiler.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: compiler.hpp 53189 2009-05-22 20:07:55Z hkaiser $ -// $Date: 2009-05-22 13:07:55 -0700 (Fri, 22 May 2009) $ -// $Revision: 53189 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_CFG_COMPILER_DIR) diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/ctps.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/ctps.hpp index 9a4aaf724..af78f47ff 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/ctps.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/ctps.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/dependent_nttp.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/dependent_nttp.hpp index 3b5a2882a..5c2e24dbb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/dependent_nttp.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/dependent_nttp.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: dependent_nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp index f5f53f7c5..9f8ea8c67 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: dmc_ambiguous_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/dtp.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/dtp.hpp index e53929bb8..4379b6b2f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/dtp.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/dtp.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: dtp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/eti.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/eti.hpp index c3fd1c60c..519d433d3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/eti.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/eti.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: eti.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/forwarding.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/forwarding.hpp index 0919d0726..b4296ad96 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/forwarding.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/forwarding.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: forwarding.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/gcc.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/gcc.hpp index b9d8f7d32..080495de1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/gcc.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/gcc.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: gcc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if defined(__GNUC__) && !defined(__EDG_VERSION__) # define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__) diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/gpu.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/gpu.hpp new file mode 100644 index 000000000..0e5ed784c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/gpu.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED + +// Copyright Eric Niebler 2014 +// +// 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/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if !defined(BOOST_MPL_CFG_GPU_ENABLED) \ + +# define BOOST_MPL_CFG_GPU_ENABLED BOOST_GPU_ENABLED + +#endif + +#if defined __CUDACC__ + +# define BOOST_MPL_CFG_GPU 1 + +#else + +# define BOOST_MPL_CFG_GPU 0 + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_apply.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_apply.hpp index cc52ebac5..4dc01c664 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_apply.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_apply.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_xxx.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_xxx.hpp index 1139b684c..b0f2f8c23 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_xxx.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/has_xxx.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_xxx.hpp 63518 2010-07-02 08:32:03Z agurtovoy $ -// $Date: 2010-07-02 01:32:03 -0700 (Fri, 02 Jul 2010) $ -// $Revision: 63518 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/integral.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/integral.hpp index 6a891604e..144542d9c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/integral.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/integral.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: integral.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/intel.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/intel.hpp index 141a95233..5bd915917 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/intel.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/intel.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: intel.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // BOOST_INTEL_CXX_VERSION is defined here: diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/lambda.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/lambda.hpp index 7be16bf7c..93fbafe07 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/lambda.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/lambda.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc.hpp index fe89cda30..8a6b92462 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // BOOST_MSVC is defined here: diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc_typename.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc_typename.hpp index 603e2755e..feedc16db 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc_typename.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/msvc_typename.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc_typename.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/nttp.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/nttp.hpp index f8bd39efa..11125a9bf 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/nttp.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/nttp.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/operators.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/operators.hpp index a6af5b167..3fb9db305 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/operators.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/operators.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: operators.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -24,6 +24,7 @@ || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) \ || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, <= 0x0295) \ || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \ + || BOOST_WORKAROUND(__NVCC__, BOOST_TESTED_AT(1)) \ ) # define BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/overload_resolution.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/overload_resolution.hpp index 9de579ff5..61e4486e9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/overload_resolution.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/overload_resolution.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: overload_resolution.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/pp_counter.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/pp_counter.hpp index 4592272f8..e7fb8d66c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/pp_counter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/pp_counter.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pp_counter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_AUX_PP_COUNTER) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/preprocessor.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/preprocessor.hpp index 39190c4fd..82ebc68fe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/preprocessor.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/preprocessor.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: preprocessor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/static_constant.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/static_constant.hpp index 02cf9c4ed..ece38fb0e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/static_constant.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/static_constant.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: static_constant.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) // BOOST_STATIC_CONSTANT is defined here: diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/ttp.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/ttp.hpp index 879ec1ddc..3aff3f84d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/ttp.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/ttp.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: ttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/typeof.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/typeof.hpp index 2244d2cd1..cde6179c6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/typeof.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/typeof.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: typeof.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/use_preprocessed.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/use_preprocessed.hpp index 4494366d8..8fd5c6075 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/use_preprocessed.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/use_preprocessed.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: use_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/config/workaround.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/config/workaround.hpp index 8ec172f67..82c632982 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/config/workaround.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/config/workaround.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: workaround.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/contains_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/contains_impl.hpp index 2dcb609c9..b80caeafe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/contains_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/contains_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: contains_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/count_args.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/count_args.hpp index 1ab000db1..b432d370e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/count_args.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/count_args.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: count_args.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/count_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/count_impl.hpp index 8b80c02fd..2f1200c6c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/count_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/count_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: count_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/empty_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/empty_impl.hpp index 0b4b97987..cfe55ae25 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/empty_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/empty_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/erase_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/erase_impl.hpp index 5fc1712f1..ab763be5a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/erase_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/erase_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/erase_key_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/erase_key_impl.hpp index e479c66ce..4d213a543 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/erase_key_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/erase_key_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/filter_iter.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/filter_iter.hpp index 6fb141177..e4237f19a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/filter_iter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/filter_iter.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: filter_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl.hpp index cc640224d..97c88c5b2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl_body.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl_body.hpp index 0750990ae..02dd645f7 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl_body.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_impl_body.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ # include # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_op.hpp index 3fc6ce94d..722c22c01 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_op.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: fold_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_pred.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_pred.hpp index f645464ea..315640030 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/fold_pred.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/fold_pred.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: fold_pred.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/front_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/front_impl.hpp index a666e6797..9493c1c4e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/front_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/front_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/full_lambda.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/full_lambda.hpp index e93119991..918aff5c0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/full_lambda.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/full_lambda.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: full_lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_apply.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_apply.hpp index cfb496e3b..9c16a3549 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_apply.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_apply.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_begin.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_begin.hpp index c2b3bdbb5..4ee415cbb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_begin.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_begin.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_begin.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_key_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_key_impl.hpp index e7c7fc4d8..7a0e9b558 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_key_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_key_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_rebind.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_rebind.hpp index f07e79e56..eb4eda613 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_rebind.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_rebind.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_rebind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_size.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_size.hpp index 23588af0b..ff29913f9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_tag.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_tag.hpp index 915a8b622..3912a76af 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/has_type.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/has_type.hpp index 4f05072b5..6744ef5b0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/has_type.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/has_type.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/include_preprocessed.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/include_preprocessed.hpp index 162b05cc0..c13434c8e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/include_preprocessed.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/include_preprocessed.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/insert_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/insert_impl.hpp index a0de6e907..03a304b58 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/insert_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/insert_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/insert_range_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/insert_range_impl.hpp index d7357b46a..baffb54a2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/insert_range_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/insert_range_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_range_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/inserter_algorithm.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/inserter_algorithm.hpp index 2d7e1d928..20ae8161c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/inserter_algorithm.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/inserter_algorithm.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: inserter_algorithm.hpp 55648 2009-08-18 05:16:53Z agurtovoy $ -// $Date: 2009-08-17 22:16:53 -0700 (Mon, 17 Aug 2009) $ -// $Revision: 55648 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/integral_wrapper.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/integral_wrapper.hpp index d36e7cbb2..6bc05f7e9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/integral_wrapper.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/integral_wrapper.hpp @@ -7,9 +7,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: integral_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! @@ -77,7 +77,7 @@ struct AUX_WRAPPER_NAME // functions that return objects of both arithmetic ('int', 'long', // 'double', etc.) and wrapped integral types (for an example, see // "mpl/example/power.cpp") - operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast(this->value); } + BOOST_CONSTEXPR operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast(this->value); } }; #if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/is_msvc_eti_arg.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/is_msvc_eti_arg.hpp index 917b57cbc..4989940ba 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/is_msvc_eti_arg.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/is_msvc_eti_arg.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: is_msvc_eti_arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_apply.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_apply.hpp index fee4d811c..41dfdfadd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_apply.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_apply.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iter_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_if_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_if_impl.hpp index ad80250d0..6372e83de 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_if_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_if_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iter_fold_if_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_impl.hpp index 7bc572078..b4d2922f5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_fold_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iter_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_push_front.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_push_front.hpp index 3a01b0360..35ccc4dfb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/iter_push_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/iter_push_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iter_push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/joint_iter.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/joint_iter.hpp index e78028d64..277580eeb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/joint_iter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/joint_iter.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: joint_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_arity_param.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_arity_param.hpp index 5418f2c90..63cfcd4f1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_arity_param.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_arity_param.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda_arity_param.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_no_ctps.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_no_ctps.hpp index 1c383b427..9e0d0203a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_no_ctps.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_no_ctps.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda_no_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_spec.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_spec.hpp index 52b1dcd55..6ffacc0a6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_spec.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_spec.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_support.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_support.hpp index 2d25348ff..5b2af5858 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_support.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/lambda_support.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda_support.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/largest_int.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/largest_int.hpp index 1b9f1cf98..feaa1eca7 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/largest_int.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/largest_int.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: largest_int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/logical_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/logical_op.hpp index d96404934..0ba251026 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/logical_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/logical_op.hpp @@ -7,9 +7,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: logical_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_dtw.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_dtw.hpp index b8953f59d..d595b231f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_dtw.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_dtw.hpp @@ -7,9 +7,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc_dtw.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_eti_base.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_eti_base.hpp index 61bd38ab5..0d8ace696 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_eti_base.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_eti_base.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc_eti_base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_is_class.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_is_class.hpp index 54a2c5766..acd40e330 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_is_class.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_is_class.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc_is_class.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_never_true.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_never_true.hpp index ca35adca9..2df9b8117 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_never_true.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_never_true.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc_never_true.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_type.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_type.hpp index 643fd83e9..bea244f31 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_type.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/msvc_type.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: msvc_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/na.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/na.hpp index b75fcdd28..f079c1e78 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/na.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/na.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: na.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/na_assert.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/na_assert.hpp index df88ba3e5..1983c0906 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/na_assert.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/na_assert.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: na_assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/na_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/na_fwd.hpp index 2409fc8a1..438824193 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/na_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/na_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: na_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/na_spec.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/na_spec.hpp index 6cd7721ca..d052fce18 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/na_spec.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/na_spec.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: na_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/nested_type_wknd.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/nested_type_wknd.hpp index cc4628672..4207abdbc 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/nested_type_wknd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/nested_type_wknd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: nested_type_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/nttp_decl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/nttp_decl.hpp index 65e292913..8c344d874 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/nttp_decl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/nttp_decl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: nttp_decl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_cast_utils.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_cast_utils.hpp index 11f04edd7..a7ac85a99 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_cast_utils.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_cast_utils.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numeric_cast_utils.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_op.hpp index 896935cc4..549255701 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/numeric_op.hpp @@ -13,9 +13,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numeric_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/order_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/order_impl.hpp index 9d8b04c74..2c145212d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/order_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/order_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: order_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/overload_names.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/overload_names.hpp index 27e86424d..f9bbb3916 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/overload_names.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/overload_names.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: overload_names.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/partition_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/partition_op.hpp index 1844d09db..79d49370f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/partition_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/partition_op.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: partition_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/pop_back_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/pop_back_impl.hpp index 05613e59f..2b54e0f83 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/pop_back_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/pop_back_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_back_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/pop_front_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/pop_front_impl.hpp index 21a76f32c..7697b1f59 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/pop_front_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/pop_front_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_front_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/add.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/add.hpp index 26a70e756..53e646ef6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/add.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/add.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: add.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/def_params_tail.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/def_params_tail.hpp index c51636e68..cab3989d1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/def_params_tail.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/def_params_tail.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: def_params_tail.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/default_params.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/default_params.hpp index 66d6d0397..c3548c6c9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/default_params.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/default_params.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: default_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/enum.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/enum.hpp index 11541a050..64c5e6a8f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/enum.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/enum.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: enum.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/ext_params.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/ext_params.hpp index a89535d6b..f5e6e502c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/ext_params.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/ext_params.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: ext_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/filter_params.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/filter_params.hpp index fefd98477..7c0df4f7d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/filter_params.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/filter_params.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: filter_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define BOOST_MPL_PP_FILTER_PARAMS_0(p1,p2,p3,p4,p5,p6,p7,p8,p9) #define BOOST_MPL_PP_FILTER_PARAMS_1(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1 diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/is_seq.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/is_seq.hpp index db7eaa40b..cb6dcb98c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/is_seq.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/is_seq.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: is_seq.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/params.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/params.hpp index ac861ecc4..acad32190 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/params.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/params.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/partial_spec_params.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/partial_spec_params.hpp index e2e1fa900..de5535cea 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/partial_spec_params.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/partial_spec_params.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: partial_spec_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/range.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/range.hpp index e69a9e194..54094ee78 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/range.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/range.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/repeat.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/repeat.hpp index 2c314eca1..051136766 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/repeat.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/repeat.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: repeat.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/sub.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/sub.hpp index 7f5e2913a..c794c749f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/sub.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/sub.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sub.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/token_equal.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/token_equal.hpp index b65f3d8bf..ffdb20f9e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/token_equal.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/token_equal.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: token_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/tuple.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/tuple.hpp index ed59407c5..755bbc58e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/tuple.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/preprocessor/tuple.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tuple.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0 #define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1 diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/ptr_to_ref.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/ptr_to_ref.hpp index e81ebe8cf..8517b3029 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/ptr_to_ref.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/ptr_to_ref.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: ptr_to_ref.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/push_back_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/push_back_impl.hpp index 732c43c80..27e7a6044 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/push_back_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/push_back_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_back_impl.hpp 55679 2009-08-20 07:50:16Z agurtovoy $ -// $Date: 2009-08-20 00:50:16 -0700 (Thu, 20 Aug 2009) $ -// $Revision: 55679 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/push_front_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/push_front_impl.hpp index ae1bc22d3..5b83ee764 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/push_front_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/push_front_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_front_impl.hpp 55679 2009-08-20 07:50:16Z agurtovoy $ -// $Date: 2009-08-20 00:50:16 -0700 (Thu, 20 Aug 2009) $ -// $Revision: 55679 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/O1_size.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/O1_size.hpp index 69452858d..9b393e849 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/O1_size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/O1_size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/back.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/back.hpp index 0d6cc6e7f..549010876 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/empty.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/empty.hpp index d78e5b3d4..574bdf2a9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/empty.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/empty.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/front.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/front.hpp index e3265ab3c..2964ab505 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/iterator.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/iterator.hpp index 5d5b1d02c..2c5290528 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/iterator.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/size.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/size.hpp index dbd8adef7..761a97cc1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/tag.hpp index f56d86f94..7f8fdde0a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/range_c/tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { namespace aux { diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl.hpp index 9c17c0129..a27a35fa1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: reverse_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl_body.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl_body.hpp index c815e0aed..0f8001066 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl_body.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_fold_impl_body.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: reverse_fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ # include # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_iter_fold_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_iter_fold_impl.hpp index 63557ce8e..83182a2e9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_iter_fold_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/reverse_iter_fold_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: reverse_iter_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/sequence_wrapper.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/sequence_wrapper.hpp index 8b49c74ed..3f5e55303 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/sequence_wrapper.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/sequence_wrapper.hpp @@ -13,9 +13,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sequence_wrapper.hpp 49271 2008-10-11 06:46:00Z agurtovoy $ -// $Date: 2008-10-10 23:46:00 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49271 $ +// $Id$ +// $Date$ +// $Revision$ # include # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/shift_op.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/shift_op.hpp index 982d66aec..b9840bf5c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/shift_op.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/shift_op.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: shift_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/single_element_iter.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/single_element_iter.hpp index e17abb947..9aceb7474 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/single_element_iter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/single_element_iter.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: single_element_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/size_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/size_impl.hpp index 73dc50d19..50f5ee918 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/size_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/size_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/sort_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/sort_impl.hpp index 76bc31147..382042190 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/sort_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/sort_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sort_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/static_cast.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/static_cast.hpp index 8c12128e3..f72d1c7c9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/static_cast.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/static_cast.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: static_cast.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity.hpp index 5e3f6e012..f01115982 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: template_arity.hpp 61584 2010-04-26 18:48:26Z agurtovoy $ -// $Date: 2010-04-26 11:48:26 -0700 (Mon, 26 Apr 2010) $ -// $Revision: 61584 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity_fwd.hpp index 44bc9d214..19d63a396 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/template_arity_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: template_arity_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { namespace aux { diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/test.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/test.hpp index f676a31e9..8d1dea62c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/test.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/test.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: test.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/test/assert.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/test/assert.hpp index 0d107dfc7..3bd8ba09c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/test/assert.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/test/assert.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/test/data.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/test/data.hpp index 6eee8239a..373e6c326 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/test/data.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/test/data.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: data.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/test/test_case.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/test/test_case.hpp index a23330caf..b168a005a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/test/test_case.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/test/test_case.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: test_case.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/traits_lambda_spec.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/traits_lambda_spec.hpp index c9b60fe78..4a7ff26b5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/traits_lambda_spec.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/traits_lambda_spec.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: traits_lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/transform_iter.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/transform_iter.hpp index 3faee5f42..e42fcc6b0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/transform_iter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/transform_iter.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: transform_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/type_wrapper.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/type_wrapper.hpp index 6d6091bd3..f3ac3079a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/type_wrapper.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/type_wrapper.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: type_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/unwrap.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/unwrap.hpp index bc734f031..caeb97d7d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/unwrap.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/unwrap.hpp @@ -11,15 +11,17 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: unwrap.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include +#include namespace boost { namespace mpl { namespace aux { template< typename F > +BOOST_MPL_CFG_GPU_ENABLED inline F& unwrap(F& f, long) { @@ -27,6 +29,7 @@ F& unwrap(F& f, long) } template< typename F > +BOOST_MPL_CFG_GPU_ENABLED inline F& unwrap(reference_wrapper& f, int) @@ -35,6 +38,7 @@ unwrap(reference_wrapper& f, int) } template< typename F > +BOOST_MPL_CFG_GPU_ENABLED inline F& unwrap(reference_wrapper const& f, int) diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/value_wknd.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/value_wknd.hpp index 7baa8bf7e..23fefde02 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/value_wknd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/value_wknd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: value_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/aux_/yes_no.hpp b/src/thirdparty/boost_lib/boost/mpl/aux_/yes_no.hpp index ebcb00dbb..21a18a21c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/aux_/yes_no.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/aux_/yes_no.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: yes_no.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/back.hpp b/src/thirdparty/boost_lib/boost/mpl/back.hpp index ff6b5d601..2778c427c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/back_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/back_fwd.hpp index c8b1fe9db..119722c31 100644 --- a/src/thirdparty/boost_lib/boost/mpl/back_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/back_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/back_inserter.hpp b/src/thirdparty/boost_lib/boost/mpl/back_inserter.hpp index ce2a2849a..8fc4083c3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/back_inserter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/back_inserter.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: back_inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/base.hpp b/src/thirdparty/boost_lib/boost/mpl/base.hpp index 0dcd712ec..8f438490e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/base.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/base.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/begin.hpp b/src/thirdparty/boost_lib/boost/mpl/begin.hpp index 9dab26505..15bdf7e38 100644 --- a/src/thirdparty/boost_lib/boost/mpl/begin.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/begin.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/begin_end.hpp b/src/thirdparty/boost_lib/boost/mpl/begin_end.hpp index 6c3accc77..b7074afd2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/begin_end.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/begin_end.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/begin_end_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/begin_end_fwd.hpp index d1edaca7c..70ef9efec 100644 --- a/src/thirdparty/boost_lib/boost/mpl/begin_end_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/begin_end_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/bind.hpp b/src/thirdparty/boost_lib/boost/mpl/bind.hpp index 25e46b4ff..63ee3f27e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bind.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bind.hpp @@ -15,9 +15,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/bind_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/bind_fwd.hpp index 35795ac00..4746edd60 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bind_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bind_fwd.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bind_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/bitand.hpp b/src/thirdparty/boost_lib/boost/mpl/bitand.hpp index 7292569f0..9c31c7929 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bitand.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bitand.hpp @@ -11,15 +11,15 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bitand.hpp 63520 2010-07-02 08:59:55Z agurtovoy $ -// $Date: 2010-07-02 01:59:55 -0700 (Fri, 02 Jul 2010) $ -// $Revision: 63520 $ +// $Id$ +// $Date$ +// $Revision$ // agurt, 23/jan/10: workaround a conflict with header's // macros, see http://tinyurl.com/ycwdxco; 'defined(bitand)' // has to be checked in a separate condition, otherwise GCC complains // about 'bitand' being an alternative token -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(bitand) # pragma push_macro("bitand") @@ -34,7 +34,7 @@ #define AUX778076_OP_TOKEN & #include -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(bitand) # pragma pop_macro("bitand") diff --git a/src/thirdparty/boost_lib/boost/mpl/bitor.hpp b/src/thirdparty/boost_lib/boost/mpl/bitor.hpp index 11f092c8e..f00974377 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bitor.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bitor.hpp @@ -11,15 +11,15 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bitor.hpp 63520 2010-07-02 08:59:55Z agurtovoy $ -// $Date: 2010-07-02 01:59:55 -0700 (Fri, 02 Jul 2010) $ -// $Revision: 63520 $ +// $Id$ +// $Date$ +// $Revision$ // agurt, 23/jan/10: workaround a conflict with header's // macros, see http://tinyurl.com/ycwdxco; 'defined(bitor)' // has to be checked in a separate condition, otherwise GCC complains // about 'bitor' being an alternative token -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(bitor) # pragma push_macro("bitor") @@ -34,7 +34,7 @@ #define AUX778076_OP_TOKEN | #include -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(bitor) # pragma pop_macro("bitor") diff --git a/src/thirdparty/boost_lib/boost/mpl/bitwise.hpp b/src/thirdparty/boost_lib/boost/mpl/bitwise.hpp index fdaa0c565..9deb23ef2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bitwise.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bitwise.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bitwise.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/bitxor.hpp b/src/thirdparty/boost_lib/boost/mpl/bitxor.hpp index 1d1ec6e5d..7f98f1737 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bitxor.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bitxor.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bitxor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME bitxor_ #define AUX778076_OP_PREFIX bitxor diff --git a/src/thirdparty/boost_lib/boost/mpl/bool.hpp b/src/thirdparty/boost_lib/boost/mpl/bool.hpp index cabf22f2c..0a6180ced 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bool.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bool.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bool.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -26,7 +26,7 @@ template< bool C_ > struct bool_ typedef integral_c_tag tag; typedef bool_ type; typedef bool value_type; - operator bool() const { return this->value; } + BOOST_CONSTEXPR operator bool() const { return this->value; } }; #if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) diff --git a/src/thirdparty/boost_lib/boost/mpl/bool_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/bool_fwd.hpp index e71ab9cc7..e62925284 100644 --- a/src/thirdparty/boost_lib/boost/mpl/bool_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/bool_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: bool_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/clear.hpp b/src/thirdparty/boost_lib/boost/mpl/clear.hpp index 9cf16fab4..c6b95edf4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/clear.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/clear.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/clear_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/clear_fwd.hpp index e660bc26e..d14a1d2b2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/clear_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/clear_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/comparison.hpp b/src/thirdparty/boost_lib/boost/mpl/comparison.hpp index 223b9efe1..99dca9dd8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/comparison.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/comparison.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: comparison.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/contains.hpp b/src/thirdparty/boost_lib/boost/mpl/contains.hpp index 620fe41e7..02c2aa4f8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/contains.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/contains.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: contains.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/contains_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/contains_fwd.hpp index af7721a59..c7c667285 100644 --- a/src/thirdparty/boost_lib/boost/mpl/contains_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/contains_fwd.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: contains_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/copy.hpp b/src/thirdparty/boost_lib/boost/mpl/copy.hpp index 6849ec87a..6eafba398 100644 --- a/src/thirdparty/boost_lib/boost/mpl/copy.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/copy.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: copy.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/copy_if.hpp b/src/thirdparty/boost_lib/boost/mpl/copy_if.hpp index c7eb283aa..96d9172df 100644 --- a/src/thirdparty/boost_lib/boost/mpl/copy_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/copy_if.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: copy_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/count.hpp b/src/thirdparty/boost_lib/boost/mpl/count.hpp index 04fdb5f30..c845662c2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/count.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/count.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: count.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/count_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/count_fwd.hpp index 4a0b4efa1..7d1ee17fa 100644 --- a/src/thirdparty/boost_lib/boost/mpl/count_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/count_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: count_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/count_if.hpp b/src/thirdparty/boost_lib/boost/mpl/count_if.hpp index d800ad015..d81c39570 100644 --- a/src/thirdparty/boost_lib/boost/mpl/count_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/count_if.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: count_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/deque.hpp b/src/thirdparty/boost_lib/boost/mpl/deque.hpp index 0fa2fcf7f..729bae97b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/deque.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/deque.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: deque.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/deref.hpp b/src/thirdparty/boost_lib/boost/mpl/deref.hpp index 15479e17c..1105ec903 100644 --- a/src/thirdparty/boost_lib/boost/mpl/deref.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/deref.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: deref.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/distance.hpp b/src/thirdparty/boost_lib/boost/mpl/distance.hpp index 8ecd3c1b2..95f4f3351 100644 --- a/src/thirdparty/boost_lib/boost/mpl/distance.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/distance.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: distance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/distance_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/distance_fwd.hpp index 766ceb429..a69a7c514 100644 --- a/src/thirdparty/boost_lib/boost/mpl/distance_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/distance_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: distance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/divides.hpp b/src/thirdparty/boost_lib/boost/mpl/divides.hpp index 6f544966e..55c8b0d10 100644 --- a/src/thirdparty/boost_lib/boost/mpl/divides.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/divides.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: divides.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME divides #define AUX778076_OP_TOKEN / diff --git a/src/thirdparty/boost_lib/boost/mpl/empty.hpp b/src/thirdparty/boost_lib/boost/mpl/empty.hpp index e25c04c3b..1185324c1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/empty.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/empty.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/empty_base.hpp b/src/thirdparty/boost_lib/boost/mpl/empty_base.hpp index 095003eba..a5841cf17 100644 --- a/src/thirdparty/boost_lib/boost/mpl/empty_base.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/empty_base.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty_base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/empty_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/empty_fwd.hpp index 4bf68681e..551c9660a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/empty_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/empty_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/empty_sequence.hpp b/src/thirdparty/boost_lib/boost/mpl/empty_sequence.hpp index fe505ea30..94f5f5a38 100644 --- a/src/thirdparty/boost_lib/boost/mpl/empty_sequence.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/empty_sequence.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/end.hpp b/src/thirdparty/boost_lib/boost/mpl/end.hpp index ddee55670..cb8d525f5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/end.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/end.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/equal.hpp b/src/thirdparty/boost_lib/boost/mpl/equal.hpp index 09e26dbba..8937ef3a1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/equal.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/equal.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/equal_to.hpp b/src/thirdparty/boost_lib/boost/mpl/equal_to.hpp index 359031c5c..5dfc87dbe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/equal_to.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/equal_to.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: equal_to.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME equal_to #define AUX778076_OP_TOKEN == diff --git a/src/thirdparty/boost_lib/boost/mpl/erase.hpp b/src/thirdparty/boost_lib/boost/mpl/erase.hpp index 2bc09ad11..abcfdbd87 100644 --- a/src/thirdparty/boost_lib/boost/mpl/erase.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/erase.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/erase_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/erase_fwd.hpp index 1f833ca02..44e38eac2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/erase_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/erase_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/erase_key.hpp b/src/thirdparty/boost_lib/boost/mpl/erase_key.hpp index 9dcca4b40..0e7b820e9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/erase_key.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/erase_key.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_key.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/erase_key_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/erase_key_fwd.hpp index cebe5c662..54265eef8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/erase_key_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/erase_key_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_key_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/eval_if.hpp b/src/thirdparty/boost_lib/boost/mpl/eval_if.hpp index f1a5b7002..e892703fd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/eval_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/eval_if.hpp @@ -4,15 +4,15 @@ // Copyright Aleksey Gurtovoy 2000-2004 // -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at +// 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/mpl for documentation. -// $Id: eval_if.hpp 61921 2010-05-11 21:33:24Z neilgroves $ -// $Date: 2010-05-11 14:33:24 -0700 (Tue, 11 May 2010) $ -// $Revision: 61921 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -43,7 +43,7 @@ struct eval_if BOOST_MPL_AUX_LAMBDA_SUPPORT(3,eval_if,(C,F1,F2)) }; -// (almost) copy & paste in order to save one more +// (almost) copy & paste in order to save one more // recursively nested template instantiation to user template< bool C diff --git a/src/thirdparty/boost_lib/boost/mpl/filter_view.hpp b/src/thirdparty/boost_lib/boost/mpl/filter_view.hpp index c56b2157c..e2830d00c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/filter_view.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/filter_view.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: filter_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/find.hpp b/src/thirdparty/boost_lib/boost/mpl/find.hpp index 7b094239b..31a8b0eb8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/find.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/find.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: find.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/find_if.hpp b/src/thirdparty/boost_lib/boost/mpl/find_if.hpp index a066e7120..83a007e77 100644 --- a/src/thirdparty/boost_lib/boost/mpl/find_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/find_if.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: find_if.hpp 49274 2008-10-11 07:22:05Z agurtovoy $ -// $Date: 2008-10-11 00:22:05 -0700 (Sat, 11 Oct 2008) $ -// $Revision: 49274 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/fold.hpp b/src/thirdparty/boost_lib/boost/mpl/fold.hpp index e5e02bd71..0bc67ef3d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/fold.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/fold.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/for_each.hpp b/src/thirdparty/boost_lib/boost/mpl/for_each.hpp index 016d99010..6b40ce166 100644 --- a/src/thirdparty/boost_lib/boost/mpl/for_each.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/for_each.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: for_each.hpp 55648 2009-08-18 05:16:53Z agurtovoy $ -// $Date: 2009-08-17 22:16:53 -0700 (Mon, 17 Aug 2009) $ -// $Revision: 55648 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -40,6 +41,7 @@ struct for_each_impl , typename TransformFunc , typename F > + BOOST_MPL_CFG_GPU_ENABLED static void execute( Iterator* , LastIterator* @@ -59,6 +61,7 @@ struct for_each_impl , typename TransformFunc , typename F > + BOOST_MPL_CFG_GPU_ENABLED static void execute( Iterator* , LastIterator* @@ -89,6 +92,7 @@ template< , typename TransformOp , typename F > +BOOST_MPL_CFG_GPU_ENABLED inline void for_each(F f, Sequence* = 0, TransformOp* = 0) { @@ -105,10 +109,13 @@ template< typename Sequence , typename F > +BOOST_MPL_CFG_GPU_ENABLED inline void for_each(F f, Sequence* = 0) { - for_each >(f); + // jfalcou: fully qualifying this call so it doesnt clash with phoenix::for_each + // ons ome compilers -- done on 02/28/2011 + boost::mpl::for_each >(f); } }} diff --git a/src/thirdparty/boost_lib/boost/mpl/front.hpp b/src/thirdparty/boost_lib/boost/mpl/front.hpp index b2c5678c1..b222ff254 100644 --- a/src/thirdparty/boost_lib/boost/mpl/front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/front_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/front_fwd.hpp index 62750010e..f01282a77 100644 --- a/src/thirdparty/boost_lib/boost/mpl/front_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/front_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/front_inserter.hpp b/src/thirdparty/boost_lib/boost/mpl/front_inserter.hpp index 7220f768b..0a6b197ef 100644 --- a/src/thirdparty/boost_lib/boost/mpl/front_inserter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/front_inserter.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front_inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/greater.hpp b/src/thirdparty/boost_lib/boost/mpl/greater.hpp index c73276b2b..b1f0a2cf1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/greater.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/greater.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: greater.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME greater #define AUX778076_OP_TOKEN > diff --git a/src/thirdparty/boost_lib/boost/mpl/greater_equal.hpp b/src/thirdparty/boost_lib/boost/mpl/greater_equal.hpp index 119710f87..7a06a62e8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/greater_equal.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/greater_equal.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: greater_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME greater_equal #define AUX778076_OP_TOKEN >= diff --git a/src/thirdparty/boost_lib/boost/mpl/has_key.hpp b/src/thirdparty/boost_lib/boost/mpl/has_key.hpp index bdb96b4e4..ac3a5c7bb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/has_key.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/has_key.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_key.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/has_key_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/has_key_fwd.hpp index 9c784a16a..54b7ed622 100644 --- a/src/thirdparty/boost_lib/boost/mpl/has_key_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/has_key_fwd.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_key_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/has_xxx.hpp b/src/thirdparty/boost_lib/boost/mpl/has_xxx.hpp index 121bc4853..82e67ddca 100644 --- a/src/thirdparty/boost_lib/boost/mpl/has_xxx.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/has_xxx.hpp @@ -12,9 +12,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_xxx.hpp 64146 2010-07-19 00:46:31Z djwalker $ -// $Date: 2010-07-18 17:46:31 -0700 (Sun, 18 Jul 2010) $ -// $Revision: 64146 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -155,10 +155,11 @@ template<> struct trait \ // SFINAE-based implementations below are derived from a USENET newsgroup's // posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST) -# elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ +# elif BOOST_WORKAROUND(BOOST_MSVC, <= 1400) \ + || (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800)) && defined(__CUDACC__)) \ || BOOST_WORKAROUND(__IBMCPP__, <= 700) -// MSVC 7.1+ & VACPP +// MSVC 7.1 & MSVC 8.0 & VACPP // agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE // applied to partial specialization to fix some apparently random failures @@ -290,18 +291,24 @@ struct trait \ # if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES) # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) # define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1 +# else +# define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 0 # endif # endif # if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION) # if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)) # define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1 +# else +# define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 0 # endif # endif # if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE) # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) # define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1 +# else +# define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 0 # endif # endif diff --git a/src/thirdparty/boost_lib/boost/mpl/identity.hpp b/src/thirdparty/boost_lib/boost/mpl/identity.hpp index 5424f7103..190d2f53f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/identity.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/identity.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: identity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/if.hpp b/src/thirdparty/boost_lib/boost/mpl/if.hpp index 245c993d9..b6bdf6c69 100644 --- a/src/thirdparty/boost_lib/boost/mpl/if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/if.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/index_if.hpp b/src/thirdparty/boost_lib/boost/mpl/index_if.hpp index 3df5763c4..a44473d2c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/index_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/index_if.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: index_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/index_of.hpp b/src/thirdparty/boost_lib/boost/mpl/index_of.hpp index 0f49f04f8..cc86a12e4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/index_of.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/index_of.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: index_of.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/inherit.hpp b/src/thirdparty/boost_lib/boost/mpl/inherit.hpp index 59715ed1a..b5427371d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/inherit.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/inherit.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: inherit.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/inherit_linearly.hpp b/src/thirdparty/boost_lib/boost/mpl/inherit_linearly.hpp index 5bc2d7fab..fa58480b8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/inherit_linearly.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/inherit_linearly.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: inherit_linearly.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/insert.hpp b/src/thirdparty/boost_lib/boost/mpl/insert.hpp index ff03de62c..5e379a497 100644 --- a/src/thirdparty/boost_lib/boost/mpl/insert.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/insert.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/insert_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/insert_fwd.hpp index 8e3208ed2..ba6b16176 100644 --- a/src/thirdparty/boost_lib/boost/mpl/insert_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/insert_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/insert_range.hpp b/src/thirdparty/boost_lib/boost/mpl/insert_range.hpp index 30baf1d91..0c362f5ae 100644 --- a/src/thirdparty/boost_lib/boost/mpl/insert_range.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/insert_range.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/insert_range_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/insert_range_fwd.hpp index de85c0e64..d9c946f2a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/insert_range_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/insert_range_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_range_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/inserter.hpp b/src/thirdparty/boost_lib/boost/mpl/inserter.hpp index 0c014d17b..964df7f69 100644 --- a/src/thirdparty/boost_lib/boost/mpl/inserter.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/inserter.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/int.hpp b/src/thirdparty/boost_lib/boost/mpl/int.hpp index 14db5482e..b7fa0a765 100644 --- a/src/thirdparty/boost_lib/boost/mpl/int.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/int.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/int_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/int_fwd.hpp index 87b043c10..03d20c1cd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/int_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/int_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: int_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/integral_c.hpp b/src/thirdparty/boost_lib/boost/mpl/integral_c.hpp index e270dc500..7a692dcab 100644 --- a/src/thirdparty/boost_lib/boost/mpl/integral_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/integral_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: integral_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/integral_c_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/integral_c_fwd.hpp index 7fcbfd59d..05e311daa 100644 --- a/src/thirdparty/boost_lib/boost/mpl/integral_c_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/integral_c_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: integral_c_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/integral_c_tag.hpp b/src/thirdparty/boost_lib/boost/mpl/integral_c_tag.hpp index 27da563c7..b6046920f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/integral_c_tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/integral_c_tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: integral_c_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/is_placeholder.hpp b/src/thirdparty/boost_lib/boost/mpl/is_placeholder.hpp index 565df89cb..9f79ef102 100644 --- a/src/thirdparty/boost_lib/boost/mpl/is_placeholder.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/is_placeholder.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: is_placeholder.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/is_sequence.hpp b/src/thirdparty/boost_lib/boost/mpl/is_sequence.hpp index 4e61fcfe4..68e036fa9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/is_sequence.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/is_sequence.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: is_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/iter_fold.hpp b/src/thirdparty/boost_lib/boost/mpl/iter_fold.hpp index 1b52dd43c..1b56b7904 100644 --- a/src/thirdparty/boost_lib/boost/mpl/iter_fold.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/iter_fold.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iter_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/iter_fold_if.hpp b/src/thirdparty/boost_lib/boost/mpl/iter_fold_if.hpp index 01847ef54..0115b7b22 100644 --- a/src/thirdparty/boost_lib/boost/mpl/iter_fold_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/iter_fold_if.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iter_fold_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/iterator_category.hpp b/src/thirdparty/boost_lib/boost/mpl/iterator_category.hpp index 6ccc1b1d9..d5ea4afee 100644 --- a/src/thirdparty/boost_lib/boost/mpl/iterator_category.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/iterator_category.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator_category.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/iterator_range.hpp b/src/thirdparty/boost_lib/boost/mpl/iterator_range.hpp index 995ddc033..a637e2241 100644 --- a/src/thirdparty/boost_lib/boost/mpl/iterator_range.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/iterator_range.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/iterator_tags.hpp b/src/thirdparty/boost_lib/boost/mpl/iterator_tags.hpp index fce273446..7c3116ab4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/iterator_tags.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/iterator_tags.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator_tags.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/joint_view.hpp b/src/thirdparty/boost_lib/boost/mpl/joint_view.hpp index 2672fad34..cd9cddac7 100644 --- a/src/thirdparty/boost_lib/boost/mpl/joint_view.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/joint_view.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: joint_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/key_type.hpp b/src/thirdparty/boost_lib/boost/mpl/key_type.hpp index e1e0cd93f..77bb37f19 100644 --- a/src/thirdparty/boost_lib/boost/mpl/key_type.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/key_type.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: key_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/key_type_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/key_type_fwd.hpp index e59b395b3..1e86b782c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/key_type_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/key_type_fwd.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: key_type_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/lambda.hpp b/src/thirdparty/boost_lib/boost/mpl/lambda.hpp index 05c27167e..cc8f6075c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/lambda.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/lambda.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/lambda_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/lambda_fwd.hpp index 16c73e4ad..57b042641 100644 --- a/src/thirdparty/boost_lib/boost/mpl/lambda_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/lambda_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lambda_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/less.hpp b/src/thirdparty/boost_lib/boost/mpl/less.hpp index 33a570c2c..63da5aa4e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/less.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/less.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: less.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME less #define AUX778076_OP_TOKEN < diff --git a/src/thirdparty/boost_lib/boost/mpl/less_equal.hpp b/src/thirdparty/boost_lib/boost/mpl/less_equal.hpp index 8b9a4ffe8..3d668c279 100644 --- a/src/thirdparty/boost_lib/boost/mpl/less_equal.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/less_equal.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: less_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME less_equal #define AUX778076_OP_TOKEN <= diff --git a/src/thirdparty/boost_lib/boost/mpl/limits/arity.hpp b/src/thirdparty/boost_lib/boost/mpl/limits/arity.hpp index 9da70ab34..8c3eb362c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/limits/arity.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/limits/arity.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) # define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5 diff --git a/src/thirdparty/boost_lib/boost/mpl/limits/list.hpp b/src/thirdparty/boost_lib/boost/mpl/limits/list.hpp index 6ae7387dc..b22d6a7b8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/limits/list.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/limits/list.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_LIMIT_LIST_SIZE) # define BOOST_MPL_LIMIT_LIST_SIZE 20 diff --git a/src/thirdparty/boost_lib/boost/mpl/limits/map.hpp b/src/thirdparty/boost_lib/boost/mpl/limits/map.hpp index 92c4a24b1..bedba6331 100644 --- a/src/thirdparty/boost_lib/boost/mpl/limits/map.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/limits/map.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_LIMIT_MAP_SIZE) # define BOOST_MPL_LIMIT_MAP_SIZE 20 diff --git a/src/thirdparty/boost_lib/boost/mpl/limits/set.hpp b/src/thirdparty/boost_lib/boost/mpl/limits/set.hpp index a4473b0fa..dbc9bd0c0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/limits/set.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/limits/set.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_LIMIT_SET_SIZE) # define BOOST_MPL_LIMIT_SET_SIZE 20 diff --git a/src/thirdparty/boost_lib/boost/mpl/limits/unrolling.hpp b/src/thirdparty/boost_lib/boost/mpl/limits/unrolling.hpp index 3914f0aaa..6dba94222 100644 --- a/src/thirdparty/boost_lib/boost/mpl/limits/unrolling.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/limits/unrolling.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: unrolling.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_LIMIT_UNROLLING) # define BOOST_MPL_LIMIT_UNROLLING 4 diff --git a/src/thirdparty/boost_lib/boost/mpl/limits/vector.hpp b/src/thirdparty/boost_lib/boost/mpl/limits/vector.hpp index 5de3811c4..900758916 100644 --- a/src/thirdparty/boost_lib/boost/mpl/limits/vector.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/limits/vector.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_LIMIT_VECTOR_SIZE) # define BOOST_MPL_LIMIT_VECTOR_SIZE 20 diff --git a/src/thirdparty/boost_lib/boost/mpl/list.hpp b/src/thirdparty/boost_lib/boost/mpl/list.hpp index 6d968314a..cff8a4ddd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/O1_size.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/O1_size.hpp index 0d93dabe2..ccbc3f1b3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/O1_size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/O1_size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/begin_end.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/begin_end.hpp index 7fbddad59..b568bee21 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/begin_end.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/begin_end.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/clear.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/clear.hpp index 3deafe7a0..b16162f7c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/clear.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/clear.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/empty.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/empty.hpp index c282cfe3d..95f924394 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/empty.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/empty.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/front.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/front.hpp index eb0b689e4..9bea1fd34 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/include_preprocessed.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/include_preprocessed.hpp index 4e7f6e450..4f7cab260 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/include_preprocessed.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/include_preprocessed.hpp @@ -7,9 +7,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/item.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/item.hpp index 24b5e4060..8505deb28 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/item.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/item.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/iterator.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/iterator.hpp index 4d0431fd7..6b5ea7863 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/iterator.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered.hpp index 7b661e51e..0cd49a6d3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if defined(BOOST_PP_IS_ITERATING) diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered_c.hpp index 0c8e9f6d1..0006fd6cf 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/numbered_c.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if defined(BOOST_PP_IS_ITERATING) diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/pop_front.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/pop_front.hpp index 9c7222897..46a041456 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/pop_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/pop_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_back.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_back.hpp index 8e9c34ba1..8f3b73e43 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_front.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_front.hpp index 942508b7a..fcfbe4ab3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/push_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/size.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/size.hpp index 9d7191f2e..f5e7feafd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/aux_/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/list/aux_/tag.hpp index e1a75337a..f5ed2bbfe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/aux_/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/aux_/tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { namespace aux { diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list0.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list0.hpp index 3ecdac34c..8e06b8d08 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list0.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list0_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list0_c.hpp index 066661faa..807ca1c2c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list0_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list0_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list10.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list10.hpp index 23546948c..d32d0d8c7 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list10.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list10.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list10_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list10_c.hpp index b1c8e1b27..25c8f9def 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list10_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list10_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list20.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list20.hpp index 29f7d5dde..724cabd23 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list20.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list20.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list20_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list20_c.hpp index d7f772ce9..0026f695a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list20_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list20_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list30.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list30.hpp index 704cbdf6f..a9004c737 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list30.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list30.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list30_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list30_c.hpp index 54fd22f92..c99657477 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list30_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list30_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list40.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list40.hpp index 11d12e36a..02f869efb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list40.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list40.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list40_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list40_c.hpp index 0ae99fc08..808d599dd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list40_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list40_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list50.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list50.hpp index 4050a81cb..f16c68ceb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list50.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list50.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list/list50_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list/list50_c.hpp index 4b5b65403..20692d898 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list/list50_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list/list50_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/list_c.hpp b/src/thirdparty/boost_lib/boost/mpl/list_c.hpp index 984f6c3b2..6c01fc66e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/list_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/list_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: list_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/logical.hpp b/src/thirdparty/boost_lib/boost/mpl/logical.hpp index f8b8fc3db..c8236b5fe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/logical.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/logical.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: logical.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/long.hpp b/src/thirdparty/boost_lib/boost/mpl/long.hpp index 1c79afd3d..c45526734 100644 --- a/src/thirdparty/boost_lib/boost/mpl/long.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/long.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: long.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/long_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/long_fwd.hpp index 17accd397..5f62f2b81 100644 --- a/src/thirdparty/boost_lib/boost/mpl/long_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/long_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: long_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/lower_bound.hpp b/src/thirdparty/boost_lib/boost/mpl/lower_bound.hpp index 058e0ba04..75eae9add 100644 --- a/src/thirdparty/boost_lib/boost/mpl/lower_bound.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/lower_bound.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: lower_bound.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map.hpp b/src/thirdparty/boost_lib/boost/mpl/map.hpp index 3355f000d..01012964f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/at_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/at_impl.hpp index e531a704c..03f125852 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/at_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/at_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/begin_end_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/begin_end_impl.hpp index b450ecf71..aeb72fa57 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/begin_end_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/begin_end_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/clear_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/clear_impl.hpp index d2020a2e4..226ae89e3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/clear_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/clear_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/contains_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/contains_impl.hpp index 67402334a..94007807d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/contains_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/contains_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: contains_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/empty_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/empty_impl.hpp index b4f3511ea..ab4fa4f98 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/empty_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/empty_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_impl.hpp index 8328e8018..978ca2f42 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_key_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_key_impl.hpp index 9a8a715f8..5e0775da5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_key_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/erase_key_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/has_key_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/has_key_impl.hpp index 3ff49c249..a463d8bcb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/has_key_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/has_key_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/include_preprocessed.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/include_preprocessed.hpp index 89e4b1646..07873d0ac 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/include_preprocessed.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/include_preprocessed.hpp @@ -7,9 +7,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/insert_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/insert_impl.hpp index ab0aad388..fb61ed961 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/insert_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/insert_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_impl.hpp 55751 2009-08-24 04:11:00Z agurtovoy $ -// $Date: 2009-08-23 21:11:00 -0700 (Sun, 23 Aug 2009) $ -// $Revision: 55751 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/item.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/item.hpp index 8ff86b39c..d0df522cd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/item.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/item.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/iterator.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/iterator.hpp index ecae6f8a2..93d9ebdd5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/iterator.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/key_type_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/key_type_impl.hpp index df883fc33..f5ce0c760 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/key_type_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/key_type_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: key_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/map0.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/map0.hpp index acba1a4b1..fd885dd37 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/map0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/map0.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/numbered.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/numbered.hpp index 453fe8783..f4512a5f4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/numbered.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/numbered.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #else diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/size_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/size_impl.hpp index 786e169cf..fd46a1cde 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/size_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/size_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/tag.hpp index 05bb3ab0a..6e3b7f466 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/tag.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { namespace aux { diff --git a/src/thirdparty/boost_lib/boost/mpl/map/aux_/value_type_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/map/aux_/value_type_impl.hpp index edf3d892e..5451b14b3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/aux_/value_type_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/aux_/value_type_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: value_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/map0.hpp b/src/thirdparty/boost_lib/boost/mpl/map/map0.hpp index c1082ffbf..e1ea897b2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/map0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/map0.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/map10.hpp b/src/thirdparty/boost_lib/boost/mpl/map/map10.hpp index efe0e6a03..7c53f3c8c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/map10.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/map10.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/map20.hpp b/src/thirdparty/boost_lib/boost/mpl/map/map20.hpp index 24500830c..f5e61b844 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/map20.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/map20.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/map30.hpp b/src/thirdparty/boost_lib/boost/mpl/map/map30.hpp index 3480ebe0e..4e632b553 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/map30.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/map30.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/map40.hpp b/src/thirdparty/boost_lib/boost/mpl/map/map40.hpp index ef928faf2..db66f7a6b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/map40.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/map40.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/map/map50.hpp b/src/thirdparty/boost_lib/boost/mpl/map/map50.hpp index 8eae6403d..1c2ef5867 100644 --- a/src/thirdparty/boost_lib/boost/mpl/map/map50.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/map/map50.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: map50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/math/fixed_c.hpp b/src/thirdparty/boost_lib/boost/mpl/math/fixed_c.hpp index 15b6b3ddf..1d78e51d0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/math/fixed_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/math/fixed_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: fixed_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/math/is_even.hpp b/src/thirdparty/boost_lib/boost/mpl/math/is_even.hpp index eb8aada7c..a39de5bd3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/math/is_even.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/math/is_even.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: is_even.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/math/rational_c.hpp b/src/thirdparty/boost_lib/boost/mpl/math/rational_c.hpp index 37429207a..dd1ac3f54 100644 --- a/src/thirdparty/boost_lib/boost/mpl/math/rational_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/math/rational_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: rational_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/max.hpp b/src/thirdparty/boost_lib/boost/mpl/max.hpp index dec4bc1fa..4a4c8c1c0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/max.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/max.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: max.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/max_element.hpp b/src/thirdparty/boost_lib/boost/mpl/max_element.hpp index cbfb71128..33244f36d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/max_element.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/max_element.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: max_element.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/min.hpp b/src/thirdparty/boost_lib/boost/mpl/min.hpp index b39461e88..d35c2c289 100644 --- a/src/thirdparty/boost_lib/boost/mpl/min.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/min.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: min.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/min_element.hpp b/src/thirdparty/boost_lib/boost/mpl/min_element.hpp index 45c0681ee..078ee1de1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/min_element.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/min_element.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: min_element.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/min_max.hpp b/src/thirdparty/boost_lib/boost/mpl/min_max.hpp index 97261bb94..77545cd35 100644 --- a/src/thirdparty/boost_lib/boost/mpl/min_max.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/min_max.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: min_max.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/minus.hpp b/src/thirdparty/boost_lib/boost/mpl/minus.hpp index 123b8afec..9f29f74b5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/minus.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/minus.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: minus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME minus #define AUX778076_OP_TOKEN - diff --git a/src/thirdparty/boost_lib/boost/mpl/modulus.hpp b/src/thirdparty/boost_lib/boost/mpl/modulus.hpp index 99338b149..5cc2eccb8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/modulus.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/modulus.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: modulus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME modulus #define AUX778076_OP_TOKEN % diff --git a/src/thirdparty/boost_lib/boost/mpl/multiplies.hpp b/src/thirdparty/boost_lib/boost/mpl/multiplies.hpp index 1c0ec9f54..53c39d98a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiplies.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiplies.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: multiplies.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/count_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/count_impl.hpp index e2fb63445..6cd4a5bd2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/count_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/count_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: count_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/insert_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/insert_impl.hpp index 8fd694e1d..208da2884 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/insert_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/insert_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/item.hpp b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/item.hpp index 86499d14d..eca21ad96 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/item.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/item.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/multiset0.hpp b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/multiset0.hpp index e29799e61..e8cb9d2a4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/multiset0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/multiset0.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: multiset0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/tag.hpp index d8fc9db8a..3988ca103 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiset/aux_/tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { namespace aux { diff --git a/src/thirdparty/boost_lib/boost/mpl/multiset/multiset0.hpp b/src/thirdparty/boost_lib/boost/mpl/multiset/multiset0.hpp index 3b05121c1..62a3c7442 100644 --- a/src/thirdparty/boost_lib/boost/mpl/multiset/multiset0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/multiset/multiset0.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: multiset0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ //#include //#include diff --git a/src/thirdparty/boost_lib/boost/mpl/negate.hpp b/src/thirdparty/boost_lib/boost/mpl/negate.hpp index 3d51caf38..d6aa06545 100644 --- a/src/thirdparty/boost_lib/boost/mpl/negate.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/negate.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: negate.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/next.hpp b/src/thirdparty/boost_lib/boost/mpl/next.hpp index fcfb01bb1..954b2226c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/next.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/next.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: next.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/next_prior.hpp b/src/thirdparty/boost_lib/boost/mpl/next_prior.hpp index c65d4c4d1..d45fa20ea 100644 --- a/src/thirdparty/boost_lib/boost/mpl/next_prior.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/next_prior.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: next_prior.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/not.hpp b/src/thirdparty/boost_lib/boost/mpl/not.hpp index 9886d7d8b..d5f602557 100644 --- a/src/thirdparty/boost_lib/boost/mpl/not.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/not.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: not.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/not_equal_to.hpp b/src/thirdparty/boost_lib/boost/mpl/not_equal_to.hpp index b6997dffd..11ef3424c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/not_equal_to.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/not_equal_to.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: not_equal_to.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME not_equal_to #define AUX778076_OP_TOKEN != diff --git a/src/thirdparty/boost_lib/boost/mpl/numeric_cast.hpp b/src/thirdparty/boost_lib/boost/mpl/numeric_cast.hpp index f890e44ee..654147044 100644 --- a/src/thirdparty/boost_lib/boost/mpl/numeric_cast.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/numeric_cast.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numeric_cast.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/or.hpp b/src/thirdparty/boost_lib/boost/mpl/or.hpp index 16b42c143..f9704d516 100644 --- a/src/thirdparty/boost_lib/boost/mpl/or.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/or.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: or.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include @@ -29,7 +29,7 @@ // 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)' // has to be checked in a separate condition, otherwise GCC complains // about 'or' being an alternative token -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(or) # pragma push_macro("or") @@ -42,7 +42,7 @@ # define BOOST_MPL_PREPROCESSED_HEADER or.hpp # include -#if defined(_MSC_VER) +#if defined(_MSC_VER) && !defined(__clang__) #ifndef __GCCXML__ #if defined(or) # pragma pop_macro("or") diff --git a/src/thirdparty/boost_lib/boost/mpl/order.hpp b/src/thirdparty/boost_lib/boost/mpl/order.hpp index e37da0e78..50da7102b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/order.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/order.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: order.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/order_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/order_fwd.hpp index bce09fa0b..d89fef110 100644 --- a/src/thirdparty/boost_lib/boost/mpl/order_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/order_fwd.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: order_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/pair.hpp b/src/thirdparty/boost_lib/boost/mpl/pair.hpp index 9336ca19e..67c01d73c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/pair.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/pair.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pair.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/pair_view.hpp b/src/thirdparty/boost_lib/boost/mpl/pair_view.hpp index 06f6bacd2..a72cf9287 100644 --- a/src/thirdparty/boost_lib/boost/mpl/pair_view.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/pair_view.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pair_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/partition.hpp b/src/thirdparty/boost_lib/boost/mpl/partition.hpp index 888653ec2..795a39bbe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/partition.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/partition.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: partition.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/placeholders.hpp b/src/thirdparty/boost_lib/boost/mpl/placeholders.hpp index 891a81851..df0373ca5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/placeholders.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/placeholders.hpp @@ -15,9 +15,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: placeholders.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) diff --git a/src/thirdparty/boost_lib/boost/mpl/plus.hpp b/src/thirdparty/boost_lib/boost/mpl/plus.hpp index 9f68c49bd..455920b5d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/plus.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/plus.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: plus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME plus #define AUX778076_OP_TOKEN + diff --git a/src/thirdparty/boost_lib/boost/mpl/pop_back.hpp b/src/thirdparty/boost_lib/boost/mpl/pop_back.hpp index e4affcaca..92fb4f1d3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/pop_back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/pop_back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/pop_back_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/pop_back_fwd.hpp index c8209a790..70957046c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/pop_back_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/pop_back_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/pop_front.hpp b/src/thirdparty/boost_lib/boost/mpl/pop_front.hpp index dead80fb0..76dfbca40 100644 --- a/src/thirdparty/boost_lib/boost/mpl/pop_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/pop_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/pop_front_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/pop_front_fwd.hpp index eb78347b9..719c8b218 100644 --- a/src/thirdparty/boost_lib/boost/mpl/pop_front_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/pop_front_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/print.hpp b/src/thirdparty/boost_lib/boost/mpl/print.hpp index c726fac0e..e3b0d315a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/print.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/print.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: print.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -37,8 +37,7 @@ namespace aux { static const unsigned value = 1; }; #endif -} // namespace aux - +} // namespace aux template struct print @@ -47,7 +46,9 @@ struct print , aux::print_base #endif { -#if defined(BOOST_MSVC) +#if defined(__clang__) + const int m_x = 1 / (sizeof(T) - sizeof(T)); +#elif defined(BOOST_MSVC) enum { n = sizeof(T) + -1 }; #elif defined(__MWERKS__) void f(int); diff --git a/src/thirdparty/boost_lib/boost/mpl/prior.hpp b/src/thirdparty/boost_lib/boost/mpl/prior.hpp index b8f0dff2d..849802cfa 100644 --- a/src/thirdparty/boost_lib/boost/mpl/prior.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/prior.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: prior.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/protect.hpp b/src/thirdparty/boost_lib/boost/mpl/protect.hpp index e3daa4fee..80574c275 100644 --- a/src/thirdparty/boost_lib/boost/mpl/protect.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/protect.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: protect.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/push_back.hpp b/src/thirdparty/boost_lib/boost/mpl/push_back.hpp index 2e8ad068e..95a2587be 100644 --- a/src/thirdparty/boost_lib/boost/mpl/push_back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/push_back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/push_back_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/push_back_fwd.hpp index ef04ff537..7a4f7a754 100644 --- a/src/thirdparty/boost_lib/boost/mpl/push_back_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/push_back_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/push_front.hpp b/src/thirdparty/boost_lib/boost/mpl/push_front.hpp index ca943bbee..e4d0dfb7f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/push_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/push_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/push_front_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/push_front_fwd.hpp index fa3667ca5..d6ad5af57 100644 --- a/src/thirdparty/boost_lib/boost/mpl/push_front_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/push_front_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/quote.hpp b/src/thirdparty/boost_lib/boost/mpl/quote.hpp index 53b57124a..242c2e7af 100644 --- a/src/thirdparty/boost_lib/boost/mpl/quote.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/quote.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: quote.hpp 49272 2008-10-11 06:50:46Z agurtovoy $ -// $Date: 2008-10-10 23:50:46 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49272 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/range_c.hpp b/src/thirdparty/boost_lib/boost/mpl/range_c.hpp index 7072ad36f..ba95062d6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/range_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/range_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: range_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/remove.hpp b/src/thirdparty/boost_lib/boost/mpl/remove.hpp index 7ed621fe9..9c72f9e6f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/remove.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/remove.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: remove.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/remove_if.hpp b/src/thirdparty/boost_lib/boost/mpl/remove_if.hpp index 1275bd43d..bbe6564b0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/remove_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/remove_if.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: remove_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/replace.hpp b/src/thirdparty/boost_lib/boost/mpl/replace.hpp index 3fab34600..bb46dfb85 100644 --- a/src/thirdparty/boost_lib/boost/mpl/replace.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/replace.hpp @@ -12,9 +12,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: replace.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/replace_if.hpp b/src/thirdparty/boost_lib/boost/mpl/replace_if.hpp index 349480e62..79466c712 100644 --- a/src/thirdparty/boost_lib/boost/mpl/replace_if.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/replace_if.hpp @@ -12,9 +12,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: replace_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/reverse.hpp b/src/thirdparty/boost_lib/boost/mpl/reverse.hpp index 3221ecbd0..dd1fc18bb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/reverse.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/reverse.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: reverse.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/reverse_fold.hpp b/src/thirdparty/boost_lib/boost/mpl/reverse_fold.hpp index bcf3157d1..87c26a9a8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/reverse_fold.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/reverse_fold.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: reverse_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/reverse_iter_fold.hpp b/src/thirdparty/boost_lib/boost/mpl/reverse_iter_fold.hpp index 9965c272a..348f295ee 100644 --- a/src/thirdparty/boost_lib/boost/mpl/reverse_iter_fold.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/reverse_iter_fold.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: reverse_iter_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/same_as.hpp b/src/thirdparty/boost_lib/boost/mpl/same_as.hpp index c82cfd7ca..4be20bc33 100644 --- a/src/thirdparty/boost_lib/boost/mpl/same_as.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/same_as.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: same_as.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/sequence_tag.hpp b/src/thirdparty/boost_lib/boost/mpl/sequence_tag.hpp index 479175e3c..f87d92b28 100644 --- a/src/thirdparty/boost_lib/boost/mpl/sequence_tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/sequence_tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sequence_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/sequence_tag_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/sequence_tag_fwd.hpp index 07a6707e0..4b0ed6f6b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/sequence_tag_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/sequence_tag_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sequence_tag_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/set.hpp b/src/thirdparty/boost_lib/boost/mpl/set.hpp index 5392d5f21..75f56dce4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/at_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/at_impl.hpp index feed3d3b9..89119c4a5 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/at_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/at_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/begin_end_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/begin_end_impl.hpp index 09d270229..259528053 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/begin_end_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/begin_end_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/clear_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/clear_impl.hpp index c0b1450ac..9c6c76030 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/clear_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/clear_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/empty_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/empty_impl.hpp index 1940c55a5..997ff023a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/empty_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/empty_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_impl.hpp index 541c785e8..c4a95b4a8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_key_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_key_impl.hpp index 3cee21dd1..f945d4fb3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_key_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/erase_key_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/has_key_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/has_key_impl.hpp index e76019579..bdc327318 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/has_key_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/has_key_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/include_preprocessed.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/include_preprocessed.hpp index 08cb73404..ffeb9c6b0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/include_preprocessed.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/include_preprocessed.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/insert_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/insert_impl.hpp index 3d3d41d93..ff180acaa 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/insert_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/insert_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/item.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/item.hpp index bc3966287..e90e4900f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/item.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/item.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include @@ -32,7 +32,7 @@ struct s_item typedef s_item item_; typedef void_ last_masked_; typedef T item_type_; - typedef Base base; + typedef typename Base::item_ base; typedef typename next< typename Base::size >::type size; typedef typename next< typename Base::order >::type order; @@ -55,7 +55,7 @@ struct s_mask typedef s_mask item_; typedef T last_masked_; typedef void_ item_type_; - typedef Base base; + typedef typename Base::item_ base; typedef typename prior< typename Base::size >::type size; BOOST_MPL_AUX_SET_OVERLOAD( aux::yes_tag, IS_MASKED, s_mask, aux::type_wrapper* ); @@ -69,7 +69,7 @@ struct s_unmask typedef s_unmask item_; typedef void_ last_masked_; typedef T item_type_; - typedef Base base; + typedef typename Base::item_ base; typedef typename next< typename Base::size >::type size; BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_unmask, aux::type_wrapper* ); diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/iterator.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/iterator.hpp index c855b3e24..9a58a25f2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/iterator.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/key_type_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/key_type_impl.hpp index 1a221680b..8e8a09054 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/key_type_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/key_type_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: key_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered.hpp index 95cea0c86..edd839d8a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered_c.hpp index 6365d2a86..130cf5d70 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/numbered_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/set0.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/set0.hpp index 82719b893..65f52a817 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/set0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/set0.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/size_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/size_impl.hpp index 2e35bdbe5..e86559669 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/size_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/size_impl.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/tag.hpp index b3e76a15a..f11fc2bbe 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/tag.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { namespace aux { diff --git a/src/thirdparty/boost_lib/boost/mpl/set/aux_/value_type_impl.hpp b/src/thirdparty/boost_lib/boost/mpl/set/aux_/value_type_impl.hpp index 19cea4e38..91cf0d00c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/aux_/value_type_impl.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/aux_/value_type_impl.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: value_type_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set0.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set0.hpp index 9fd195071..840373104 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set0.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set0_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set0_c.hpp index cf548890f..7e7f77a96 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set0_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set0_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set10.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set10.hpp index 5cf0add71..fa876b25e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set10.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set10.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set10_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set10_c.hpp index e40fd5533..34abd9840 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set10_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set10_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set20.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set20.hpp index c4928bfb8..0cdff4780 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set20.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set20.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set20_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set20_c.hpp index 669420e02..e3de0447e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set20_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set20_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set30.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set30.hpp index 401cc2314..b0344546a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set30.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set30.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set30_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set30_c.hpp index ba5ce1cdf..e006e1cd6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set30_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set30_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set40.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set40.hpp index a22d54c36..5fa2cd0e4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set40.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set40.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set40_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set40_c.hpp index d593bd565..bce5a80dc 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set40_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set40_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set50.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set50.hpp index 4f425372b..0c2bfc01a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set50.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set50.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set/set50_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set/set50_c.hpp index f64c8ee73..077dbf762 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set/set50_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set/set50_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/set_c.hpp b/src/thirdparty/boost_lib/boost/mpl/set_c.hpp index c7bf8497e..c0f8e37fa 100644 --- a/src/thirdparty/boost_lib/boost/mpl/set_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/set_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: set_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/shift_left.hpp b/src/thirdparty/boost_lib/boost/mpl/shift_left.hpp index a20bf05de..55e4f649d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/shift_left.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/shift_left.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: shift_left.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME shift_left #define AUX778076_OP_TOKEN << diff --git a/src/thirdparty/boost_lib/boost/mpl/shift_right.hpp b/src/thirdparty/boost_lib/boost/mpl/shift_right.hpp index a03444c04..1ae1e35eb 100644 --- a/src/thirdparty/boost_lib/boost/mpl/shift_right.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/shift_right.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: shift_right.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME shift_right #define AUX778076_OP_TOKEN >> diff --git a/src/thirdparty/boost_lib/boost/mpl/single_view.hpp b/src/thirdparty/boost_lib/boost/mpl/single_view.hpp index 132121fbf..a872bb1fc 100644 --- a/src/thirdparty/boost_lib/boost/mpl/single_view.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/single_view.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: single_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/size.hpp b/src/thirdparty/boost_lib/boost/mpl/size.hpp index 54b13cbb2..12ffefbb7 100644 --- a/src/thirdparty/boost_lib/boost/mpl/size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/size_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/size_fwd.hpp index 8702da7f8..c72628dd1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/size_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/size_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/size_t.hpp b/src/thirdparty/boost_lib/boost/mpl/size_t.hpp index 54a05c6a2..99e9b41d0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/size_t.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/size_t.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size_t.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/size_t_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/size_t_fwd.hpp index 396a521ff..ffdf4b32d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/size_t_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/size_t_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size_t_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include // make sure 'size_t' is placed into 'std' diff --git a/src/thirdparty/boost_lib/boost/mpl/sizeof.hpp b/src/thirdparty/boost_lib/boost/mpl/sizeof.hpp index 018f82600..cf5e41c65 100644 --- a/src/thirdparty/boost_lib/boost/mpl/sizeof.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/sizeof.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sizeof.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/sort.hpp b/src/thirdparty/boost_lib/boost/mpl/sort.hpp index 04bdad6fa..961aeab8c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/sort.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/sort.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: sort.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/stable_partition.hpp b/src/thirdparty/boost_lib/boost/mpl/stable_partition.hpp index 93066bb03..e010de3cf 100644 --- a/src/thirdparty/boost_lib/boost/mpl/stable_partition.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/stable_partition.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: stable_partition.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/string.hpp b/src/thirdparty/boost_lib/boost/mpl/string.hpp index c62d8ab9b..345918f90 100644 --- a/src/thirdparty/boost_lib/boost/mpl/string.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/string.hpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include #include #include @@ -59,7 +59,7 @@ namespace boost { namespace mpl #define BOOST_MPL_MULTICHAR_LENGTH(c) \ (std::size_t)((c0xffffff)+(c>0xffff)+(c>0xff)+1)) - #if defined(BOOST_LITTLE_ENDIAN) && defined(__SUNPRO_CC) + #if defined(BOOST_ENDIAN_LITTLE_BYTE) && defined(__SUNPRO_CC) #define BOOST_MPL_MULTICHAR_AT(c,i) \ (char)(0xff&((unsigned)(c)>>(8*(std::size_t)(i)))) diff --git a/src/thirdparty/boost_lib/boost/mpl/switch.hpp b/src/thirdparty/boost_lib/boost/mpl/switch.hpp index b5cba77fa..8edc38fad 100644 --- a/src/thirdparty/boost_lib/boost/mpl/switch.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/switch.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: switch.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/tag.hpp index fc0aee233..858627753 100644 --- a/src/thirdparty/boost_lib/boost/mpl/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/times.hpp b/src/thirdparty/boost_lib/boost/mpl/times.hpp index c73256df7..f309557c6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/times.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/times.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: times.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #define AUX778076_OP_NAME times #define AUX778076_OP_TOKEN * diff --git a/src/thirdparty/boost_lib/boost/mpl/transform.hpp b/src/thirdparty/boost_lib/boost/mpl/transform.hpp index cb2b64ed9..4d3e2a049 100644 --- a/src/thirdparty/boost_lib/boost/mpl/transform.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/transform.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: transform.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/transform_view.hpp b/src/thirdparty/boost_lib/boost/mpl/transform_view.hpp index 88b46b118..6c0e0b6dd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/transform_view.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/transform_view.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: transform_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/unique.hpp b/src/thirdparty/boost_lib/boost/mpl/unique.hpp index 7e9c1e9de..80a27da4e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/unique.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/unique.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: unique.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/unpack_args.hpp b/src/thirdparty/boost_lib/boost/mpl/unpack_args.hpp index 1e4d48c94..f64ace338 100644 --- a/src/thirdparty/boost_lib/boost/mpl/unpack_args.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/unpack_args.hpp @@ -14,9 +14,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: unpack_args.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/upper_bound.hpp b/src/thirdparty/boost_lib/boost/mpl/upper_bound.hpp index caf5cdff1..ff943e60e 100644 --- a/src/thirdparty/boost_lib/boost/mpl/upper_bound.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/upper_bound.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: upper_bound.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/value_type.hpp b/src/thirdparty/boost_lib/boost/mpl/value_type.hpp index ad34393a7..5b8c822e3 100644 --- a/src/thirdparty/boost_lib/boost/mpl/value_type.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/value_type.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: value_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/value_type_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/value_type_fwd.hpp index e9f0b2849..d8635bfe4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/value_type_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/value_type_fwd.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: value_type_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ namespace boost { namespace mpl { diff --git a/src/thirdparty/boost_lib/boost/mpl/vector.hpp b/src/thirdparty/boost_lib/boost/mpl/vector.hpp index 833f19315..479983d5c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/O1_size.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/O1_size.hpp index 3ca8d214c..ac9e3cf88 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/O1_size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/O1_size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/at.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/at.hpp index 9da05956c..0a7583ccf 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/at.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/at.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/back.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/back.hpp index ce84c7a01..b66363ec1 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/begin_end.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/begin_end.hpp index d79ef9a07..aa3445156 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/begin_end.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/begin_end.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/clear.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/clear.hpp index 3308518a2..b06d8be75 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/clear.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/clear.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/empty.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/empty.hpp index 84c879222..5490a5f72 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/empty.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/empty.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/front.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/front.hpp index ff2414eeb..a358db52c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/include_preprocessed.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/include_preprocessed.hpp index 5c1600821..a676116f6 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/include_preprocessed.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/include_preprocessed.hpp @@ -9,9 +9,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/item.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/item.hpp index da2b01ba9..71538ceb4 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/item.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/item.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/iterator.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/iterator.hpp index 770ed15d0..32df31569 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/iterator.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/iterator.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered.hpp index 04265a39a..b3f03873b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered_c.hpp index 6a7cf40e5..4c159f948 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/numbered_c.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_back.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_back.hpp index a43a3a6b7..1d95e355c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_front.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_front.hpp index a448d25bf..c94b8711c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/pop_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_back.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_back.hpp index d8783ccb4..527828c9b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_back.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_back.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_front.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_front.hpp index 26b5f0002..f315de58b 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_front.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/push_front.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/size.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/size.hpp index 41b7be635..c131e8866 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/size.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/size.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/tag.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/tag.hpp index 0f37e92ad..90d16e38c 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/tag.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/tag.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/vector0.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/vector0.hpp index b3bb13bba..402667360 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/aux_/vector0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/aux_/vector0.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector0.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector0.hpp index 9d18104eb..39759ddc2 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector0.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector0.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector0_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector0_c.hpp index eb1dcf98b..0e60215dd 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector0_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector0_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector10.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector10.hpp index 848dd82c0..53a2a163a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector10.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector10.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector10_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector10_c.hpp index 4e6cf3b6e..be52d2f7f 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector10_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector10_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector20.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector20.hpp index 173eacfff..96d1b9f45 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector20.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector20.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector20_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector20_c.hpp index c6b7187c2..3913f2602 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector20_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector20_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector30.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector30.hpp index 476ec354b..b2f0a5eb0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector30.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector30.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector30_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector30_c.hpp index c20d8f980..94cdab465 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector30_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector30_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector40.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector40.hpp index 69203d0cb..2d2ef8195 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector40.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector40.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector40_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector40_c.hpp index bd7310c14..25e2ebf3d 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector40_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector40_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector50.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector50.hpp index 4c3e23181..dc2d5c20a 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector50.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector50.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector/vector50_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector/vector50_c.hpp index 2d2e70560..7388bf404 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector/vector50_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector/vector50_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/vector_c.hpp b/src/thirdparty/boost_lib/boost/mpl/vector_c.hpp index d9f35d0b5..316ce65f8 100644 --- a/src/thirdparty/boost_lib/boost/mpl/vector_c.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/vector_c.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: vector_c.hpp 49271 2008-10-11 06:46:00Z agurtovoy $ -// $Date: 2008-10-10 23:46:00 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49271 $ +// $Id$ +// $Date$ +// $Revision$ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include diff --git a/src/thirdparty/boost_lib/boost/mpl/void.hpp b/src/thirdparty/boost_lib/boost/mpl/void.hpp index ad5aa5646..3dcbdd1d0 100644 --- a/src/thirdparty/boost_lib/boost/mpl/void.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/void.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: void.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/mpl/void_fwd.hpp b/src/thirdparty/boost_lib/boost/mpl/void_fwd.hpp index 9643dec30..86078b5c9 100644 --- a/src/thirdparty/boost_lib/boost/mpl/void_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/void_fwd.hpp @@ -10,9 +10,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: void_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $ -// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $ -// $Revision: 49267 $ +// $Id$ +// $Date$ +// $Revision$ #include diff --git a/src/thirdparty/boost_lib/boost/mpl/zip_view.hpp b/src/thirdparty/boost_lib/boost/mpl/zip_view.hpp index 4bc26c1ee..d709230dc 100644 --- a/src/thirdparty/boost_lib/boost/mpl/zip_view.hpp +++ b/src/thirdparty/boost_lib/boost/mpl/zip_view.hpp @@ -11,9 +11,9 @@ // // See http://www.boost.org/libs/mpl for documentation. -// $Id: zip_view.hpp 61591 2010-04-26 21:31:09Z agurtovoy $ -// $Date: 2010-04-26 14:31:09 -0700 (Mon, 26 Apr 2010) $ -// $Revision: 61591 $ +// $Id$ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/multi_index/composite_key.hpp b/src/thirdparty/boost_lib/boost/multi_index/composite_key.hpp index 2c21a6a41..cf3349d6f 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/composite_key.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/composite_key.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2011 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,19 +9,17 @@ #ifndef BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP #define BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include #include -#include #include #include #include #include -#include #include #include #include @@ -59,12 +57,8 @@ */ #if !defined(BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE) -#if defined(BOOST_MSVC)&&(BOOST_MSVC<1300) -#define BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE 5 -#else #define BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE 10 #endif -#endif /* maximum number of key extractors in a composite key */ @@ -114,17 +108,14 @@ namespace detail{ /* n-th key extractor of a composite key */ -template +template struct nth_key_from_value { typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple; - typedef typename prevent_eti< + typedef typename mpl::eval_if_c< + N::value, tuples::element, - typename mpl::eval_if_c< - N::value, - tuples::element, - mpl::identity - >::type + mpl::identity >::type type; }; @@ -146,7 +137,7 @@ struct BOOST_PP_CAT(key_,name) \ typedef tuples::null_type type; \ }; \ \ -template \ +template \ struct BOOST_PP_CAT(nth_composite_key_,name) \ { \ typedef typename nth_key_from_value::type key_from_value; \ @@ -589,16 +580,6 @@ struct composite_key_result /* composite_key */ -/* NB. Some overloads of operator() have an extra dummy parameter int=0. - * This disambiguator serves several purposes: - * - Without it, MSVC++ 6.0 incorrectly regards some overloads as - * specializations of a previous member function template. - * - MSVC++ 6.0/7.0 seem to incorrectly treat some different memfuns - * as if they have the same signature. - * - If remove_const is broken due to lack of PTS, int=0 avoids the - * declaration of memfuns with identical signature. - */ - template< typename Value, BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,KeyFromValue) @@ -648,7 +629,7 @@ struct composite_key: return result_type(*this,x.get()); } - result_type operator()(const reference_wrapper& x,int=0)const + result_type operator()(const reference_wrapper& x)const { return result_type(*this,x.get()); } @@ -1238,7 +1219,6 @@ BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER * for composite_key_results enabling interoperation with tuples of values. */ -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace std{ template @@ -1278,34 +1258,6 @@ struct hash >: }; } /* namespace boost */ -#else -/* Lacking template partial specialization, std::equal_to, std::less and - * std::greater will still work for composite_key_results although without - * tuple interoperability. To achieve the same graceful degrading with - * boost::hash, we define the appropriate hash_value overload. - */ - -namespace boost{ - -#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) -namespace multi_index{ -#endif - -template -inline std::size_t hash_value( - const boost::multi_index::composite_key_result& x) -{ - boost::multi_index::composite_key_result_hash< - boost::multi_index::composite_key_result > h; - return h(x); -} - -#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) -} /* namespace multi_index */ -#endif - -} /* namespace boost */ -#endif #undef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER #undef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/access_specifier.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/access_specifier.hpp index 84c2f7dc9..f3346e836 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/access_specifier.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/access_specifier.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP #define BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -42,8 +42,7 @@ * official Sun Studio 12. */ -#if BOOST_WORKAROUND(__GNUC__, <3)||\ - BOOST_WORKAROUND(__GNUC__,==3)&&(__GNUC_MINOR__<4)||\ +#if BOOST_WORKAROUND(__GNUC__,==3)&&(__GNUC_MINOR__<4)||\ BOOST_WORKAROUND(BOOST_MSVC,==1310)||\ BOOST_WORKAROUND(BOOST_MSVC,==1400)||\ BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590)) diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/adl_swap.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/adl_swap.hpp index e78235d76..02b064422 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/adl_swap.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/adl_swap.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP #define BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/archive_constructed.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/archive_constructed.hpp index ee00dfaff..0cf7991e8 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/archive_constructed.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/archive_constructed.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP #define BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/auto_space.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/auto_space.hpp index 9b0a0dc61..9d78c3a36 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/auto_space.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/auto_space.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP #define BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -17,7 +17,6 @@ #include #include #include -#include #include #include @@ -40,17 +39,14 @@ namespace detail{ * "of zero length", http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14176 * C++ Standard Library Defect Report List (Revision 28), issue 199 * "What does allocate(0) return?", - * http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#199 + * http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199 */ template > struct auto_space:private noncopyable { - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,T - >::type + typedef typename boost::detail::allocator::rebind_to< + Allocator,T >::type::pointer pointer; explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1): diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/base_type.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/base_type.hpp index d25332e4e..8c9b62b71 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/base_type.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/base_type.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP #define BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -20,7 +20,6 @@ #include #include #include -#include #include namespace boost{ @@ -33,17 +32,6 @@ namespace detail{ * a index list. */ -#if BOOST_WORKAROUND(BOOST_MSVC,<1310) -struct index_applier -{ - template - struct apply: - msvc_index_specifier:: - template result_index_class - { - }; -}; -#else struct index_applier { template @@ -54,7 +42,6 @@ struct index_applier BOOST_NESTED_TEMPLATE index_class::type type; }; }; -#endif template struct nth_layer diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/bidir_node_iterator.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/bidir_node_iterator.hpp index 2155255c4..9bb04701f 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/bidir_node_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/bidir_node_iterator.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP #define BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/bucket_array.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/bucket_array.hpp index a6772adb7..f688ba162 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/bucket_array.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/bucket_array.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP #define BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -17,8 +17,11 @@ #include #include #include -#include #include +#include +#include +#include +#include #include #include @@ -36,115 +39,143 @@ namespace detail{ /* bucket structure for use by hashed indices */ -class bucket_array_base:private noncopyable -{ -protected: - inline static std::size_t next_prime(std::size_t n) - { - static const std::size_t prime_list[]={ - 53ul, 97ul, 193ul, 389ul, 769ul, - 1543ul, 3079ul, 6151ul, 12289ul, 24593ul, - 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, - 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, - 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, - 1610612741ul, 3221225473ul, +#define BOOST_MULTI_INDEX_BA_SIZES_32BIT \ +(53ul)(97ul)(193ul)(389ul)(769ul) \ +(1543ul)(3079ul)(6151ul)(12289ul)(24593ul) \ +(49157ul)(98317ul)(196613ul)(393241ul)(786433ul) \ +(1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul) \ +(50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \ +(1610612741ul)(3221225473ul) #if ((((ULONG_MAX>>16)>>16)>>16)>>15)==0 /* unsigned long less than 64 bits */ - 4294967291ul +#define BOOST_MULTI_INDEX_BA_SIZES \ +BOOST_MULTI_INDEX_BA_SIZES_32BIT \ +(4294967291ul) #else - /* obtained with aid from - * http://javaboutique.internet.com/prime_numb/ - * http://www.rsok.com/~jrm/next_ten_primes.html - * and verified with - * http://www.alpertron.com.ar/ECM.HTM - */ - - 6442450939ul, 12884901893ul, 25769803751ul, 51539607551ul, - 103079215111ul, 206158430209ul, 412316860441ul, 824633720831ul, - 1649267441651ul, 3298534883309ul, 6597069766657ul, 13194139533299ul, - 26388279066623ul, 52776558133303ul, 105553116266489ul, 211106232532969ul, - 422212465066001ul, 844424930131963ul, 1688849860263953ul, - 3377699720527861ul, 6755399441055731ul, 13510798882111483ul, - 27021597764222939ul, 54043195528445957ul, 108086391056891903ul, - 216172782113783843ul, 432345564227567621ul, 864691128455135207ul, - 1729382256910270481ul, 3458764513820540933ul, 6917529027641081903ul, - 13835058055282163729ul, 18446744073709551557ul + /* obtained with aid from + * http://javaboutique.internet.com/prime_numb/ + * http://www.rsok.com/~jrm/next_ten_primes.html + * and verified with + * http://www.alpertron.com.ar/ECM.HTM + */ + +#define BOOST_MULTI_INDEX_BA_SIZES \ +BOOST_MULTI_INDEX_BA_SIZES_32BIT \ +(6442450939ul)(12884901893ul)(25769803751ul)(51539607551ul) \ +(103079215111ul)(206158430209ul)(412316860441ul)(824633720831ul) \ +(1649267441651ul)(3298534883309ul)(6597069766657ul)(13194139533299ul) \ +(26388279066623ul)(52776558133303ul)(105553116266489ul)(211106232532969ul) \ +(422212465066001ul)(844424930131963ul)(1688849860263953ul) \ +(3377699720527861ul)(6755399441055731ul)(13510798882111483ul) \ +(27021597764222939ul)(54043195528445957ul)(108086391056891903ul) \ +(216172782113783843ul)(432345564227567621ul)(864691128455135207ul) \ +(1729382256910270481ul)(3458764513820540933ul)(6917529027641081903ul) \ +(13835058055282163729ul)(18446744073709551557ul) #endif - }; - static const std::size_t prime_list_size= - sizeof(prime_list)/sizeof(prime_list[0]); +template /* templatized to have in-header static var defs */ +class bucket_array_base:private noncopyable +{ +protected: + static const std::size_t sizes[]; + + static std::size_t size_index(std::size_t n) + { + const std::size_t *bound=std::lower_bound(sizes,sizes+sizes_length,n); + if(bound==sizes+sizes_length)--bound; + return bound-sizes; + } + +#define BOOST_MULTI_INDEX_BA_POSITION_CASE(z,n,_) \ + case n:return hash%BOOST_PP_SEQ_ELEM(n,BOOST_MULTI_INDEX_BA_SIZES); - std::size_t const *bound= - std::lower_bound(prime_list,prime_list+prime_list_size,n); - if(bound==prime_list+prime_list_size)bound--; - return *bound; + static std::size_t position(std::size_t hash,std::size_t size_index_) + { + /* Accelerate hash%sizes[size_index_] by replacing with a switch on + * hash%Ci expressions, each Ci a compile-time constant, which the + * compiler can implement without using integer division. + */ + + switch(size_index_){ + default: /* never used */ + BOOST_PP_REPEAT( + BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES), + BOOST_MULTI_INDEX_BA_POSITION_CASE,~) + } } + +private: + static const std::size_t sizes_length; }; +template +const std::size_t bucket_array_base<_>::sizes[]={ + BOOST_PP_SEQ_ENUM(BOOST_MULTI_INDEX_BA_SIZES) +}; + +template +const std::size_t bucket_array_base<_>::sizes_length= + sizeof(bucket_array_base<_>::sizes)/ + sizeof(bucket_array_base<_>::sizes[0]); + +#undef BOOST_MULTI_INDEX_BA_POSITION_CASE +#undef BOOST_MULTI_INDEX_BA_SIZES +#undef BOOST_MULTI_INDEX_BA_SIZES_32BIT + template -class bucket_array:public bucket_array_base +class bucket_array:bucket_array_base<> { - typedef typename prevent_eti< - Allocator, - hashed_index_node_impl< - typename boost::detail::allocator::rebind_to< - Allocator, - char - >::type - > - >::type node_impl_type; + typedef bucket_array_base<> super; + typedef hashed_index_base_node_impl< + typename boost::detail::allocator::rebind_to< + Allocator, + char + >::type + > base_node_impl_type; public: - typedef typename node_impl_type::pointer pointer; + typedef typename base_node_impl_type::base_pointer base_pointer; + typedef typename base_node_impl_type::pointer pointer; - bucket_array(const Allocator& al,pointer end_,std::size_t size): - size_(bucket_array_base::next_prime(size)), - spc(al,size_+1) + bucket_array(const Allocator& al,pointer end_,std::size_t size_): + size_index_(super::size_index(size_)), + spc(al,super::sizes[size_index_]+1) { - clear(); - end()->next()=end_; - end_->next()=end(); + clear(end_); } std::size_t size()const { - return size_; + return super::sizes[size_index_]; } std::size_t position(std::size_t hash)const { - return hash%size_; + return super::position(hash,size_index_); } - pointer begin()const{return buckets();} - pointer end()const{return buckets()+size_;} - pointer at(std::size_t n)const{return buckets()+n;} + base_pointer begin()const{return buckets();} + base_pointer end()const{return buckets()+size();} + base_pointer at(std::size_t n)const{return buckets()+n;} - std::size_t first_nonempty(std::size_t n)const + void clear(pointer end_) { - for(;;++n){ - pointer x=at(n); - if(x->next()!=x)return n; - } - } - - void clear() - { - for(pointer x=begin(),y=end();x!=y;++x)x->next()=x; - } + for(base_pointer x=begin(),y=end();x!=y;++x)x->prior()=pointer(0); + end()->prior()=end_->prior()=end_; + end_->next()=end(); + } void swap(bucket_array& x) { - std::swap(size_,x.size_); + std::swap(size_index_,x.size_index_); spc.swap(x.spc); } private: - std::size_t size_; - auto_space spc; + std::size_t size_index_; + auto_space spc; - pointer buckets()const + base_pointer buckets()const { return spc.data(); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/converter.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/converter.hpp index a46cff621..3e04a3e82 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/converter.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/converter.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP #define BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/copy_map.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/copy_map.hpp index 4279a8d0c..a0b6cad59 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/copy_map.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/copy_map.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP #define BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -17,7 +17,6 @@ #include #include #include -#include #include #include #include @@ -110,20 +109,18 @@ class copy_map:private noncopyable } private: - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,Node>::type - >::type allocator_type; - typedef typename allocator_type::pointer allocator_pointer; - - allocator_type al_; - std::size_t size_; - auto_space,Allocator> spc; - std::size_t n; - Node* header_org_; - Node* header_cpy_; - bool released; + typedef typename boost::detail::allocator::rebind_to< + Allocator,Node + >::type allocator_type; + typedef typename allocator_type::pointer allocator_pointer; + + allocator_type al_; + std::size_t size_; + auto_space,Allocator> spc; + std::size_t n; + Node* header_org_; + Node* header_cpy_; + bool released; void deallocate(Node* node) { diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/do_not_copy_elements_tag.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/do_not_copy_elements_tag.hpp index a7b3f1889..f0fa73042 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/do_not_copy_elements_tag.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/do_not_copy_elements_tag.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP #define BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/duplicates_iterator.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/duplicates_iterator.hpp index 027dabd21..cbebf2640 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/duplicates_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/duplicates_iterator.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP #define BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/has_tag.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/has_tag.hpp index 83b28ccb6..217b61143 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/has_tag.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/has_tag.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP #define BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_args.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_args.hpp index 4972f9bbe..81902f5a4 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_args.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_args.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP #define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_iterator.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_iterator.hpp index 352c1d805..f8e983dbb 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_iterator.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP #define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -19,6 +19,7 @@ #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) #include #include +#include #endif namespace boost{ @@ -30,10 +31,13 @@ namespace detail{ /* Iterator class for hashed indices. */ -template +struct hashed_index_global_iterator_tag{}; +struct hashed_index_local_iterator_tag{}; + +template class hashed_index_iterator: public forward_iterator_helper< - hashed_index_iterator, + hashed_index_iterator, typename Node::value_type, std::ptrdiff_t, const typename Node::value_type*, @@ -41,9 +45,7 @@ class hashed_index_iterator: { public: hashed_index_iterator(){} - hashed_index_iterator(Node* node_,BucketArray* buckets_): - node(node_),buckets(buckets_) - {} + hashed_index_iterator(Node* node_):node(node_){} const typename Node::value_type& operator*()const { @@ -52,7 +54,7 @@ class hashed_index_iterator: hashed_index_iterator& operator++() { - Node::increment(node,buckets->begin(),buckets->end()); + this->increment(Category()); return *this; } @@ -70,16 +72,42 @@ class hashed_index_iterator: { node_base_type* bnode=node; ar< - void load(Archive& ar,const unsigned int) + void load(Archive& ar,const unsigned int version) + { + load(ar,version,Category()); + } + + template + void load( + Archive& ar,const unsigned int version,hashed_index_global_iterator_tag) { node_base_type* bnode; ar>>serialization::make_nvp("pointer",bnode); node=static_cast(bnode); - ar>>serialization::make_nvp("pointer",buckets); + if(version<1){ + BucketArray* throw_away; /* consume unused ptr */ + ar>>serialization::make_nvp("pointer",throw_away); + } + } + + template + void load( + Archive& ar,const unsigned int version,hashed_index_local_iterator_tag) + { + node_base_type* bnode; + ar>>serialization::make_nvp("pointer",bnode); + node=static_cast(bnode); + if(version<1){ + BucketArray* buckets; + ar>>serialization::make_nvp("pointer",buckets); + if(buckets&&node&&node->impl()==buckets->end()->prior()){ + /* end local_iterators used to point to end node, now they are null */ + node=0; + } + } } #endif @@ -90,14 +118,24 @@ class hashed_index_iterator: Node* get_node()const{return node;} private: - Node* node; - BucketArray* buckets; + + void increment(hashed_index_global_iterator_tag) + { + Node::increment(node); + } + + void increment(hashed_index_local_iterator_tag) + { + Node::increment_local(node); + } + + Node* node; }; -template +template bool operator==( - const hashed_index_iterator& x, - const hashed_index_iterator& y) + const hashed_index_iterator& x, + const hashed_index_iterator& y) { return x.get_node()==y.get_node(); } @@ -106,6 +144,22 @@ bool operator==( } /* namespace multi_index */ +#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) +/* class version = 1 : hashed_index_iterator does no longer serialize a bucket + * array pointer. + */ + +namespace serialization { +template +struct version< + boost::multi_index::detail::hashed_index_iterator +> +{ + BOOST_STATIC_CONSTANT(int,value=1); +}; +} /* namespace serialization */ +#endif + } /* namespace boost */ #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_node.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_node.hpp index edb2c1064..cfc60f648 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_node.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/hash_index_node.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,14 +9,13 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP #define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include -#include -#include +#include namespace boost{ @@ -24,104 +23,706 @@ namespace multi_index{ namespace detail{ -/* singly-linked node for use by hashed_index */ +/* Certain C++ requirements on unordered associative containers (see LWG issue + * #579) imply a data structure where nodes are linked in a single list, which + * in its turn forces implementors to add additional overhed per node to + * associate each with its corresponding bucket. Others resort to storing hash + * values, we use an alternative structure providing unconditional O(1) + * manipulation, even in situations of unfair hash distribution, plus some + * lookup speedups. For unique indices we maintain a doubly linked list of + * nodes except that if N is the first node of a bucket its associated + * bucket node is embedded between N and the preceding node in the following + * manner: + * + * +---+ +---+ +---+ +---+ + * <--+ |<--+ | <--+ |<--+ | + * ... | B0| | B1| ... | B1| | B2| ... + * | |-+ | +--> | |-+ | +--> + * +-+-+ | +---+ +-+-+ | +---+ + * | ^ | ^ + * | | | | + * | +-+ | +-+ + * | | | | + * v | v | + * --+---+---+---+-- --+---+---+---+-- + * ... | | B1| | ... | | B2| | ... + * --+---+---+---+-- --+---+---+---+-- + * + * + * The fist and last nodes of buckets can be checked with + * + * first node of a bucket: Npn != N + * last node of a bucket: Nnp != N + * + * (n and p short for ->next(), ->prior(), bucket nodes have prior pointers + * only). Pure insert and erase (without lookup) can be unconditionally done + * in O(1). + * For non-unique indices we add the following additional complexity: when + * there is a group of 3 or more equivalent elements, they are linked as + * follows: + * + * +-----------------------+ + * | v + * +---+ | +---+ +---+ +---+ + * | | +-+ | | |<--+ | + * | F | | S | ... | P | | L | + * | +-->| | | +-+ | | + * +---+ +---+ +---+ | +---+ + * ^ | + * +-----------------------+ + * + * F, S, P and L are the first, second, penultimate and last node in the + * group, respectively (S and P can coincide if the group has size 3.) This + * arrangement is used to skip equivalent elements in O(1) when doing lookup, + * while preserving O(1) insert/erase. The following invariants identify + * special positions (some of the operations have to be carefully implemented + * as Xnn is not valid if Xn points to a bucket): + * + * first node of a bucket: Npnp == N + * last node of a bucket: Nnpp == N + * first node of a group: Nnp != N && Nnppn == N + * second node of a group: Npn != N && Nppnn == N + * n-1 node of a group: Nnp != N && Nnnpp == N + * last node of a group: Npn != N && Npnnp == N + * + * The memory overhead is one pointer per bucket plus two pointers per node, + * probably unbeatable. The resulting structure is bidirectonally traversable, + * though currently we are just providing forward iteration. + */ + +template +struct hashed_index_node_impl; + +/* half-header (only prior() pointer) to use for the bucket array */ template -struct hashed_index_node_impl +struct hashed_index_base_node_impl { - typedef typename prevent_eti< + typedef typename + boost::detail::allocator::rebind_to< + Allocator,hashed_index_base_node_impl + >::type::pointer base_pointer; + typedef typename + boost::detail::allocator::rebind_to< + Allocator,hashed_index_base_node_impl + >::type::const_pointer const_base_pointer; + typedef typename + boost::detail::allocator::rebind_to< Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,hashed_index_node_impl - >::type - >::type::pointer pointer; - typedef typename prevent_eti< + hashed_index_node_impl + >::type::pointer pointer; + typedef typename + boost::detail::allocator::rebind_to< Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,hashed_index_node_impl - >::type - >::type::const_pointer const_pointer; + hashed_index_node_impl + >::type::const_pointer const_pointer; + + pointer& prior(){return prior_;} + pointer prior()const{return prior_;} + +private: + pointer prior_; +}; + +/* full header (prior() and next()) for the nodes */ + +template +struct hashed_index_node_impl:hashed_index_base_node_impl +{ +private: + typedef hashed_index_base_node_impl super; + +public: + typedef typename super::base_pointer base_pointer; + typedef typename super::const_base_pointer const_base_pointer; + typedef typename super::pointer pointer; + typedef typename super::const_pointer const_pointer; + + base_pointer& next(){return next_;} + base_pointer next()const{return next_;} + + static pointer pointer_from(base_pointer x) + { + return static_cast(static_cast(&*x)); + } + + static base_pointer base_pointer_from(pointer x) + { + return static_cast(&*x); + } + +private: + base_pointer next_; +}; + +/* Boost.MultiIndex requires machinery to reverse unlink operations. A simple + * way to make a pointer-manipulation function undoable is to templatize + * its internal pointer assignments with a functor that, besides doing the + * assignment, keeps track of the original pointer values and can later undo + * the operations in reverse order. + */ + +struct default_assigner +{ + template void operator()(T& x,const T& val){x=val;} +}; + +template +struct unlink_undo_assigner +{ + typedef typename Node::base_pointer base_pointer; + typedef typename Node::pointer pointer; + + unlink_undo_assigner():pointer_track_count(0),base_pointer_track_count(0){} + + void operator()(pointer& x,pointer val) + { + pointer_tracks[pointer_track_count].x=&x; + pointer_tracks[pointer_track_count++].val=x; + x=val; + } + + void operator()(base_pointer& x,base_pointer val) + { + base_pointer_tracks[base_pointer_track_count].x=&x; + base_pointer_tracks[base_pointer_track_count++].val=x; + x=val; + } + + void operator()() /* undo op */ + { + /* in the absence of aliasing, restitution order is immaterial */ + + while(pointer_track_count--){ + *(pointer_tracks[pointer_track_count].x)= + pointer_tracks[pointer_track_count].val; + } + while(base_pointer_track_count--){ + *(base_pointer_tracks[base_pointer_track_count].x)= + base_pointer_tracks[base_pointer_track_count].val; + } + } + + struct pointer_track {pointer* x; pointer val;}; + struct base_pointer_track{base_pointer* x; base_pointer val;}; + + /* We know the maximum number of pointer and base pointer assignments that + * the two unlink versions do, so we can statically reserve the needed + * storage. + */ + + pointer_track pointer_tracks[3]; + int pointer_track_count; + base_pointer_track base_pointer_tracks[2]; + int base_pointer_track_count; +}; + +/* algorithmic stuff for unique and non-unique variants */ + +struct hashed_unique_tag{}; +struct hashed_non_unique_tag{}; + +template +struct hashed_index_node_alg; + +template +struct hashed_index_node_alg +{ + typedef typename Node::base_pointer base_pointer; + typedef typename Node::const_base_pointer const_base_pointer; + typedef typename Node::pointer pointer; + typedef typename Node::const_pointer const_pointer; + + static bool is_first_of_bucket(pointer x) + { + return x->prior()->next()!=base_pointer_from(x); + } + + static pointer after(pointer x) + { + return is_last_of_bucket(x)?x->next()->prior():pointer_from(x->next()); + } + + static pointer after_local(pointer x) + { + return is_last_of_bucket(x)?pointer(0):pointer_from(x->next()); + } + + static pointer next_to_inspect(pointer x) + { + return is_last_of_bucket(x)?pointer(0):pointer_from(x->next()); + } + + static void link(pointer x,base_pointer buc,pointer end) + { + if(buc->prior()==pointer(0)){ /* empty bucket */ + x->prior()=end->prior(); + x->next()=end->prior()->next(); + x->prior()->next()=buc; + buc->prior()=x; + end->prior()=x; + } + else{ + x->prior()=buc->prior()->prior(); + x->next()=base_pointer_from(buc->prior()); + buc->prior()=x; + x->next()->prior()=x; + } + } + + static void unlink(pointer x) + { + default_assigner assign; + unlink(x,assign); + } + + typedef unlink_undo_assigner unlink_undo; + + template + static void unlink(pointer x,Assigner& assign) + { + if(is_first_of_bucket(x)){ + if(is_last_of_bucket(x)){ + assign(x->prior()->next()->prior(),pointer(0)); + assign(x->prior()->next(),x->next()); + assign(x->next()->prior()->prior(),x->prior()); + } + else{ + assign(x->prior()->next()->prior(),pointer_from(x->next())); + assign(x->next()->prior(),x->prior()); + } + } + else if(is_last_of_bucket(x)){ + assign(x->prior()->next(),x->next()); + assign(x->next()->prior()->prior(),x->prior()); + } + else{ + assign(x->prior()->next(),x->next()); + assign(x->next()->prior(),x->prior()); + } + } - pointer& next(){return next_;} - pointer next()const{return next_;} + /* used only at rehashing */ - /* algorithmic stuff */ + static void append(pointer x,pointer end) + { + x->prior()=end->prior(); + x->next()=end->prior()->next(); + x->prior()->next()=base_pointer_from(x); + end->prior()=x; + } - static void increment(pointer& x,pointer bbegin,pointer bend) + static bool unlink_last(pointer end) { - std::less_equal leq; + /* returns true iff bucket is emptied */ - x=x->next(); - if(leq(bbegin,x)&&leq(x,bend)){ /* bucket node */ - do{ - ++x; - }while(x->next()==x); - x=x->next(); + pointer x=end->prior(); + if(x->prior()->next()==base_pointer_from(x)){ + x->prior()->next()=x->next(); + end->prior()=x->prior(); + return false; + } + else{ + x->prior()->next()->prior()=pointer(0); + x->prior()->next()=x->next(); + end->prior()=x->prior(); + return true; } } - static void link(pointer x,pointer pos) +private: + static pointer pointer_from(base_pointer x) { - x->next()=pos->next(); - pos->next()=x; + return Node::pointer_from(x); + } + + static base_pointer base_pointer_from(pointer x) + { + return Node::base_pointer_from(x); + } + + static bool is_last_of_bucket(pointer x) + { + return x->next()->prior()!=x; + } +}; + +template +struct hashed_index_node_alg +{ + typedef typename Node::base_pointer base_pointer; + typedef typename Node::const_base_pointer const_base_pointer; + typedef typename Node::pointer pointer; + typedef typename Node::const_pointer const_pointer; + + static bool is_first_of_bucket(pointer x) + { + return x->prior()->next()->prior()==x; + } + + static bool is_first_of_group(pointer x) + { + return + x->next()->prior()!=x&& + x->next()->prior()->prior()->next()==base_pointer_from(x); + } + + static pointer after(pointer x) + { + if(x->next()->prior()==x)return pointer_from(x->next()); + if(x->next()->prior()->prior()==x)return x->next()->prior(); + if(x->next()->prior()->prior()->next()==base_pointer_from(x)) + return pointer_from(x->next()); + return pointer_from(x->next())->next()->prior(); + } + + static pointer after_local(pointer x) + { + if(x->next()->prior()==x)return pointer_from(x->next()); + if(x->next()->prior()->prior()==x)return pointer(0); + if(x->next()->prior()->prior()->next()==base_pointer_from(x)) + return pointer_from(x->next()); + return pointer_from(x->next())->next()->prior(); + } + + static pointer next_to_inspect(pointer x) + { + if(x->next()->prior()==x)return pointer_from(x->next()); + if(x->next()->prior()->prior()==x)return pointer(0); + if(x->next()->prior()->next()->prior()!=x->next()->prior()) + return pointer(0); + return pointer_from(x->next()->prior()->next()); + } + + static void link(pointer x,base_pointer buc,pointer end) + { + if(buc->prior()==pointer(0)){ /* empty bucket */ + x->prior()=end->prior(); + x->next()=end->prior()->next(); + x->prior()->next()=buc; + buc->prior()=x; + end->prior()=x; + } + else{ + x->prior()=buc->prior()->prior(); + x->next()=base_pointer_from(buc->prior()); + buc->prior()=x; + x->next()->prior()=x; + } }; + static void link(pointer x,pointer first,pointer last) + { + x->prior()=first->prior(); + x->next()=base_pointer_from(first); + if(is_first_of_bucket(first)){ + x->prior()->next()->prior()=x; + } + else{ + x->prior()->next()=base_pointer_from(x); + } + + if(first==last){ + last->prior()=x; + } + else if(first->next()==base_pointer_from(last)){ + first->prior()=last; + first->next()=base_pointer_from(x); + } + else{ + pointer second=pointer_from(first->next()), + lastbutone=last->prior(); + second->prior()=first; + first->prior()=last; + lastbutone->next()=base_pointer_from(x); + } + } + static void unlink(pointer x) { - pointer y=x->next(); - while(y->next()!=x){y=y->next();} - y->next()=x->next(); + default_assigner assign; + unlink(x,assign); + } + + typedef unlink_undo_assigner unlink_undo; + + template + static void unlink(pointer x,Assigner& assign) + { + if(x->prior()->next()==base_pointer_from(x)){ + if(x->next()->prior()==x){ + left_unlink(x,assign); + right_unlink(x,assign); + } + else if(x->next()->prior()->prior()==x){ /* last of bucket */ + left_unlink(x,assign); + right_unlink_last_of_bucket(x,assign); + } + else if(x->next()->prior()->prior()->next()== + base_pointer_from(x)){ /* first of group size */ + left_unlink(x,assign); + right_unlink_first_of_group(x,assign); + } + else{ /* n-1 of group */ + unlink_last_but_one_of_group(x,assign); + } + } + else if(x->prior()->next()->prior()==x){ /* first of bucket */ + if(x->next()->prior()==x){ + left_unlink_first_of_bucket(x,assign); + right_unlink(x,assign); + } + else if(x->next()->prior()->prior()==x){ /* last of bucket */ + assign(x->prior()->next()->prior(),pointer(0)); + assign(x->prior()->next(),x->next()); + assign(x->next()->prior()->prior(),x->prior()); + } + else{ /* first of group */ + left_unlink_first_of_bucket(x,assign); + right_unlink_first_of_group(x,assign); + } + } + else if(x->next()->prior()->prior()==x){ /* last of group and bucket */ + left_unlink_last_of_group(x,assign); + right_unlink_last_of_bucket(x,assign); + } + else if(pointer_from(x->prior()->prior()->next()) + ->next()==base_pointer_from(x)){ /* second of group */ + unlink_second_of_group(x,assign); + } + else{ /* last of group, ~(last of bucket) */ + left_unlink_last_of_group(x,assign); + right_unlink(x,assign); + } + } + + /* used only at rehashing */ + + static void link_range( + pointer first,pointer last,base_pointer buc,pointer cend) + { + if(buc->prior()==pointer(0)){ /* empty bucket */ + first->prior()=cend->prior(); + last->next()=cend->prior()->next(); + first->prior()->next()=buc; + buc->prior()=first; + cend->prior()=last; + } + else{ + first->prior()=buc->prior()->prior(); + last->next()=base_pointer_from(buc->prior()); + buc->prior()=first; + last->next()->prior()=last; + } } - static pointer prev(pointer x) + static void append_range(pointer first,pointer last,pointer cend) { - pointer y=x->next(); - while(y->next()!=x){y=y->next();} - return y; + first->prior()=cend->prior(); + last->next()=cend->prior()->next(); + first->prior()->next()=base_pointer_from(first); + cend->prior()=last; } - static void unlink_next(pointer x) + static std::pair unlink_last_group(pointer end) { - x->next()=x->next()->next(); + /* returns first of group true iff bucket is emptied */ + + pointer x=end->prior(); + if(x->prior()->next()==base_pointer_from(x)){ + x->prior()->next()=x->next(); + end->prior()=x->prior(); + return std::make_pair(x,false); + } + else if(x->prior()->next()->prior()==x){ + x->prior()->next()->prior()=pointer(0); + x->prior()->next()=x->next(); + end->prior()=x->prior(); + return std::make_pair(x,true); + } + else{ + pointer y=pointer_from(x->prior()->next()); + + if(y->prior()->next()==base_pointer_from(y)){ + y->prior()->next()=x->next(); + end->prior()=y->prior(); + return std::make_pair(y,false); + } + else{ + y->prior()->next()->prior()=pointer(0); + y->prior()->next()=x->next(); + end->prior()=y->prior(); + return std::make_pair(y,true); + } + } + } + + static void unlink_range(pointer first,pointer last) + { + if(is_first_of_bucket(first)){ + if(is_last_of_bucket(last)){ + first->prior()->next()->prior()=pointer(0); + first->prior()->next()=last->next(); + last->next()->prior()->prior()=first->prior(); + } + else{ + first->prior()->next()->prior()=pointer_from(last->next()); + last->next()->prior()=first->prior(); + } + } + else if(is_last_of_bucket(last)){ + first->prior()->next()=last->next(); + last->next()->prior()->prior()=first->prior(); + } + else{ + first->prior()->next()=last->next(); + last->next()->prior()=first->prior(); + } } private: - pointer next_; + static pointer pointer_from(base_pointer x) + { + return Node::pointer_from(x); + } + + static base_pointer base_pointer_from(pointer x) + { + return Node::base_pointer_from(x); + } + + static bool is_last_of_bucket(pointer x) + { + return x->next()->prior()->prior()==x; + } + + template + static void left_unlink(pointer x,Assigner& assign) + { + assign(x->prior()->next(),x->next()); + } + + template + static void right_unlink(pointer x,Assigner& assign) + { + assign(x->next()->prior(),x->prior()); + } + + template + static void left_unlink_first_of_bucket(pointer x,Assigner& assign) + { + assign(x->prior()->next()->prior(),pointer_from(x->next())); + } + + template + static void right_unlink_last_of_bucket(pointer x,Assigner& assign) + { + assign(x->next()->prior()->prior(),x->prior()); + } + + template + static void right_unlink_first_of_group(pointer x,Assigner& assign) + { + pointer second=pointer_from(x->next()), + last=second->prior(), + lastbutone=last->prior(); + if(second==lastbutone){ + assign(second->next(),base_pointer_from(last)); + assign(second->prior(),x->prior()); + } + else{ + assign(lastbutone->next(),base_pointer_from(second)); + assign(second->next()->prior(),last); + assign(second->prior(),x->prior()); + } + } + + template + static void left_unlink_last_of_group(pointer x,Assigner& assign) + { + pointer lastbutone=x->prior(), + first=pointer_from(lastbutone->next()), + second=pointer_from(first->next()); + if(lastbutone==second){ + assign(lastbutone->prior(),first); + assign(lastbutone->next(),x->next()); + } + else{ + assign(second->prior(),lastbutone); + assign(lastbutone->prior()->next(),base_pointer_from(first)); + assign(lastbutone->next(),x->next()); + } + } + + template + static void unlink_last_but_one_of_group(pointer x,Assigner& assign) + { + pointer first=pointer_from(x->next()), + second=pointer_from(first->next()), + last=second->prior(); + if(second==x){ + assign(last->prior(),first); + assign(first->next(),base_pointer_from(last)); + } + else{ + assign(last->prior(),x->prior()); + assign(x->prior()->next(),base_pointer_from(first)); + } + } + + template + static void unlink_second_of_group(pointer x,Assigner& assign) + { + pointer last=x->prior(), + lastbutone=last->prior(), + first=pointer_from(lastbutone->next()); + if(lastbutone==x){ + assign(first->next(),base_pointer_from(last)); + assign(last->prior(),first); + } + else{ + assign(first->next(),x->next()); + assign(x->next()->prior(),last); + } + } }; template struct hashed_index_node_trampoline: - prevent_eti< - Super, - hashed_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type + hashed_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > { - typedef typename prevent_eti< - Super, - hashed_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type impl_type; + typedef typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type impl_allocator_type; + typedef hashed_index_node_impl impl_type; }; -template -struct hashed_index_node:Super,hashed_index_node_trampoline +template +struct hashed_index_node: + Super,hashed_index_node_trampoline { private: typedef hashed_index_node_trampoline trampoline; public: - typedef typename trampoline::impl_type impl_type; - typedef typename trampoline::pointer impl_pointer; - typedef typename trampoline::const_pointer const_impl_pointer; + typedef typename trampoline::impl_type impl_type; + typedef hashed_index_node_alg< + impl_type,Category> node_alg; + typedef typename trampoline::base_pointer impl_base_pointer; + typedef typename trampoline::const_base_pointer const_impl_base_pointer; + typedef typename trampoline::pointer impl_pointer; + typedef typename trampoline::const_pointer const_impl_pointer; + + impl_pointer& prior(){return trampoline::prior();} + impl_pointer prior()const{return trampoline::prior();} + impl_base_pointer& next(){return trampoline::next();} + impl_base_pointer next()const{return trampoline::next();} impl_pointer impl() { @@ -147,12 +748,16 @@ struct hashed_index_node:Super,hashed_index_node_trampoline static_cast(&*x)); } - static void increment( - hashed_index_node*& x,impl_pointer bbegin,impl_pointer bend) + /* interoperability with hashed_index_iterator */ + + static void increment(hashed_index_node*& x) + { + x=from_impl(node_alg::after(x->impl())); + } + + static void increment_local(hashed_index_node*& x) { - impl_pointer xi=x->impl(); - trampoline::increment(xi,bbegin,bend); - x=from_impl(xi); + x=from_impl(node_alg::after_local(x->impl())); } }; diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/header_holder.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/header_holder.hpp index 8716e83af..ca8a9b2ed 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/header_holder.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/header_holder.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP #define BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/index_base.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/index_base.hpp index a43214a75..99000ed48 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/index_base.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/index_base.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2013 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,12 +9,13 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP #define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include +#include #include #include #include @@ -61,9 +62,10 @@ class index_base Value,IndexSpecifierList,Allocator> final_type; typedef tuples::null_type ctor_args_list; typedef typename - boost::detail::allocator::rebind_to< - Allocator, - typename Allocator::value_type>::type final_allocator_type; + boost::detail::allocator::rebind_to< + Allocator, + typename Allocator::value_type + >::type final_allocator_type; typedef mpl::vector0<> index_type_list; typedef mpl::vector0<> iterator_type_list; typedef mpl::vector0<> const_iterator_type_list; @@ -96,43 +98,60 @@ class index_base const index_base&,const copy_map_type&) {} - node_type* insert_(const value_type& v,node_type* x,lvalue_tag) + final_node_type* insert_(const value_type& v,final_node_type*& x,lvalue_tag) { - boost::detail::allocator::construct(&x->value(),v); + x=final().allocate_node(); + BOOST_TRY{ + boost::detail::allocator::construct(&x->value(),v); + } + BOOST_CATCH(...){ + final().deallocate_node(x); + BOOST_RETHROW; + } + BOOST_CATCH_END return x; } - node_type* insert_(const value_type& v,node_type* x,rvalue_tag) + final_node_type* insert_(const value_type& v,final_node_type*& x,rvalue_tag) { - /* This shoud have used a modified, T&&-compatible version of - * boost::detail::allocator::construct, but - * is too old and venerable to mess - * with; besides, it is a general internal utility and the imperfect - * perfect forwarding emulation of Boost.Move might break other libs. - */ - - new (&x->value()) value_type(boost::move(const_cast(v))); + x=final().allocate_node(); + BOOST_TRY{ + /* This shoud have used a modified, T&&-compatible version of + * boost::detail::allocator::construct, but + * is too old and venerable to + * mess with; besides, it is a general internal utility and the imperfect + * perfect forwarding emulation of Boost.Move might break other libs. + */ + + new (&x->value()) value_type(boost::move(const_cast(v))); + } + BOOST_CATCH(...){ + final().deallocate_node(x); + BOOST_RETHROW; + } + BOOST_CATCH_END return x; } - node_type* insert_(const value_type&,node_type* x,emplaced_tag) + final_node_type* insert_(const value_type&,final_node_type*& x,emplaced_tag) { return x; } - node_type* insert_(const value_type& v,node_type*,node_type* x,lvalue_tag) + final_node_type* insert_( + const value_type& v,node_type*,final_node_type*& x,lvalue_tag) { - boost::detail::allocator::construct(&x->value(),v); - return x; + return insert_(v,x,lvalue_tag()); } - node_type* insert_(const value_type& v,node_type*,node_type* x,rvalue_tag) + final_node_type* insert_( + const value_type& v,node_type*,final_node_type*& x,rvalue_tag) { - new (&x->value()) value_type(boost::move(const_cast(v))); - return x; + return insert_(v,x,rvalue_tag()); } - node_type* insert_(const value_type&,node_type*,node_type* x,emplaced_tag) + final_node_type* insert_( + const value_type&,node_type*,final_node_type*& x,emplaced_tag) { return x; } @@ -201,6 +220,9 @@ class index_base std::pair final_insert_rv_(const value_type& x) {return final().insert_rv_(x);} template + std::pair final_insert_ref_(const T& t) + {return final().insert_ref_(t);} + template std::pair final_insert_ref_(T& t) {return final().insert_ref_(t);} @@ -218,6 +240,10 @@ class index_base const value_type& x,final_node_type* position) {return final().insert_rv_(x,position);} template + std::pair final_insert_ref_( + const T& t,final_node_type* position) + {return final().insert_ref_(t,position);} + template std::pair final_insert_ref_( T& t,final_node_type* position) {return final().insert_ref_(t,position);} diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/index_loader.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/index_loader.hpp index 001c01bb2..3f0428c59 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/index_loader.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/index_loader.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP #define BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/index_matcher.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/index_matcher.hpp index 7e275e136..f3675acd4 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/index_matcher.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/index_matcher.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP #define BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/index_node_base.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/index_node_base.hpp index ee9f1c67f..150eb75e7 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/index_node_base.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/index_node_base.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP #define BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -85,9 +85,7 @@ struct index_node_base:private pod_value_holder }; template -Node* node_from_value( - const Value* p - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node)) +Node* node_from_value(const Value* p) { typedef typename Node::allocator_type allocator_type; return static_cast( diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/index_saver.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/index_saver.hpp index d9e6bc7cc..ae09d4eba 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/index_saver.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/index_saver.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP #define BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/invariant_assert.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/invariant_assert.hpp index d5fc256d8..c6c547c7c 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/invariant_assert.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/invariant_assert.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP #define BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/is_index_list.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/is_index_list.hpp index 9ee30baf2..f6a24218b 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/is_index_list.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/is_index_list.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP #define BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/iter_adaptor.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/iter_adaptor.hpp index 034618458..7a032350b 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/iter_adaptor.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/iter_adaptor.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,13 +9,12 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP #define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include -#include #include namespace boost{ @@ -294,12 +293,9 @@ template struct iter_adaptor_base { typedef iter_adaptor_selector< - typename Base::iterator_category> selector; - typedef typename prevent_eti< - selector, - typename mpl::apply2< - selector,Derived,Base>::type - >::type type; + typename Base::iterator_category> selector; + typedef typename mpl::apply2< + selector,Derived,Base>::type type; }; template diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/modify_key_adaptor.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/modify_key_adaptor.hpp index 8a93b9648..6df89b183 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/modify_key_adaptor.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/modify_key_adaptor.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP #define BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/msvc_index_specifier.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/msvc_index_specifier.hpp deleted file mode 100644 index 4766e539a..000000000 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/msvc_index_specifier.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. - * 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/multi_index for library home page. - */ - -#ifndef BOOST_MULTI_INDEX_DETAIL_MSVC_INDEX_SPECIFIER_HPP -#define BOOST_MULTI_INDEX_DETAIL_MSVC_INDEX_SPECIFIER_HPP - -#if defined(_MSC_VER)&&(_MSC_VER>=1200) -#pragma once -#endif - -#include /* keep it first to prevent nasty warns in MSVC */ -#include - -#if BOOST_WORKAROUND(BOOST_MSVC,<1310) -/* Workaround for a problem in MSVC with dependent template typedefs - * when accesing index specifiers. - * Modeled after (thanks, Aleksey!) - */ - -#include - -namespace boost{ - -namespace multi_index{ - -namespace detail{ - -template -struct msvc_index_specifier -{ - template struct fake_index_type:IndexSpecifier{}; - template<> struct fake_index_type - { - template - struct node_class{}; - - template - struct index_class{}; - }; - - template - struct result_node_class: - fake_index_type::value>:: - template node_class - { - }; - - template - struct result_index_class: - fake_index_type::value>:: - template index_class - { - }; -}; - -} /* namespace multi_index::detail */ - -} /* namespace multi_index */ - -} /* namespace boost */ - -#endif /* workaround */ - -#endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/no_duplicate_tags.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/no_duplicate_tags.hpp index 9b56e8371..ba216ed82 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/no_duplicate_tags.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/no_duplicate_tags.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP #define BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/node_type.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/node_type.hpp index 0e87261aa..7fe85cf96 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/node_type.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/node_type.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP #define BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -22,7 +22,6 @@ #include #include #include -#include #include namespace boost{ @@ -35,17 +34,6 @@ namespace detail{ * index list. */ -#if BOOST_WORKAROUND(BOOST_MSVC,<1310) -struct index_node_applier -{ - template - struct apply: - msvc_index_specifier< mpl::deref::type >:: - template result_node_class - { - }; -}; -#else struct index_node_applier { template @@ -56,7 +44,6 @@ struct index_node_applier BOOST_NESTED_TEMPLATE node_class::type type; }; }; -#endif template struct multi_index_node_type diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_args.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_args.hpp index bb8eb4129..3e2641f2f 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_args.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_args.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP #define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_node.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_node.hpp index edc4329dd..60727e04e 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_node.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_node.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -36,14 +36,13 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP #define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include #include -#include #if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES) #include @@ -70,22 +69,18 @@ struct ordered_index_node_impl; /* fwd decl. */ template struct ordered_index_node_std_base { - typedef typename prevent_eti< + typedef typename + boost::detail::allocator::rebind_to< Allocator, - typename boost::detail::allocator::rebind_to< - Allocator, - ordered_index_node_impl - >::type - >::type::pointer pointer; - typedef typename prevent_eti< + ordered_index_node_impl + >::type::pointer pointer; + typedef typename + boost::detail::allocator::rebind_to< Allocator, - typename boost::detail::allocator::rebind_to< - Allocator, - ordered_index_node_impl - >::type - >::type::const_pointer const_pointer; - typedef ordered_index_color& color_ref; - typedef pointer& parent_ref; + ordered_index_node_impl + >::type::const_pointer const_pointer; + typedef ordered_index_color& color_ref; + typedef pointer& parent_ref; ordered_index_color& color(){return color_;} ordered_index_color color()const{return color_;} @@ -216,12 +211,9 @@ struct ordered_index_node_impl_base: !(has_uintptr_type::value)|| (alignment_of >::value%2)|| !(is_same< - typename prevent_eti< + typename boost::detail::allocator::rebind_to< Allocator, - typename boost::detail::allocator::rebind_to< - Allocator, - ordered_index_node_impl - >::type + ordered_index_node_impl >::type::pointer, ordered_index_node_impl*>::value), ordered_index_node_std_base, @@ -557,25 +549,19 @@ struct ordered_index_node_impl:ordered_index_node_impl_base template struct ordered_index_node_trampoline: - prevent_eti< - Super, - ordered_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type + ordered_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > { - typedef typename prevent_eti< - Super, - ordered_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type impl_type; + typedef ordered_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > impl_type; }; template diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_ops.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_ops.hpp index caa71aa27..d42f5f1a2 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_ops.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/ord_index_ops.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -36,7 +36,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP #define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/prevent_eti.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/prevent_eti.hpp deleted file mode 100644 index 56c067a3d..000000000 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/prevent_eti.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. - * 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/multi_index for library home page. - */ - -#ifndef BOOST_MULTI_INDEX_DETAIL_PREVENT_ETI_HPP -#define BOOST_MULTI_INDEX_DETAIL_PREVENT_ETI_HPP - -#if defined(_MSC_VER)&&(_MSC_VER>=1200) -#pragma once -#endif - -#include /* keep it first to prevent nasty warns in MSVC */ -#include - -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) -#include -#include -#include -#endif - -namespace boost{ - -namespace multi_index{ - -namespace detail{ - -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) -/* See - * http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?Effective_MPL - * Item 5.6, Beware of the 'early template instantiation' trap. - */ - -template -struct prevent_eti -{ - typedef typename mpl::if_< - mpl::aux::msvc_never_true, - mpl::integral_c, - Construct - >::type type; -}; -#else -template -struct prevent_eti -{ - typedef Construct type; -}; -#endif - -} /* namespace multi_index::detail */ - -} /* namespace multi_index */ - -} /* namespace boost */ - -#endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_loader.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_loader.hpp index 793c52177..4b00345a6 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_loader.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_loader.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP #define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -17,7 +17,6 @@ #include #include #include -#include #include #include #include @@ -45,15 +44,12 @@ template class random_access_index_loader_base:private noncopyable { protected: - typedef typename prevent_eti< - Allocator, - random_access_index_node_impl< - typename boost::detail::allocator::rebind_to< - Allocator, - char - >::type - > - >::type node_impl_type; + typedef random_access_index_node_impl< + typename boost::detail::allocator::rebind_to< + Allocator, + char + >::type + > node_impl_type; typedef typename node_impl_type::pointer node_impl_pointer; typedef random_access_index_ptr_array ptr_array; @@ -86,14 +82,14 @@ class random_access_index_loader_base:private noncopyable } } - void rearrange(node_impl_pointer position,node_impl_pointer x) + void rearrange(node_impl_pointer position_,node_impl_pointer x) { preprocess(); /* only incur this penalty if rearrange() is ever called */ - if(position==node_impl_pointer(0))position=header; + if(position_==node_impl_pointer(0))position_=header; next(prev(x))=next(x); prev(next(x))=prev(x); - prev(x)=position; - next(x)=next(position); + prev(x)=position_; + next(x)=next(position_); next(prev(x))=prev(next(x))=x; } @@ -161,9 +157,10 @@ class random_access_index_loader: super(al_,ptrs_) {} - void rearrange(Node* position,Node *x) + void rearrange(Node* position_,Node *x) { - super::rearrange(position?position->impl():node_impl_pointer(0),x->impl()); + super::rearrange( + position_?position_->impl():node_impl_pointer(0),x->impl()); } }; diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_node.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_node.hpp index 43b252681..991f6dab8 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_node.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_node.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP #define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -17,7 +17,6 @@ #include #include #include -#include #include #include @@ -30,24 +29,18 @@ namespace detail{ template struct random_access_index_node_impl { - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,random_access_index_node_impl - >::type - >::type::pointer pointer; - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,random_access_index_node_impl - >::type - >::type::const_pointer const_pointer; - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,pointer - >::type - >::type::pointer ptr_pointer; + typedef typename + boost::detail::allocator::rebind_to< + Allocator,random_access_index_node_impl + >::type::pointer pointer; + typedef typename + boost::detail::allocator::rebind_to< + Allocator,random_access_index_node_impl + >::type::const_pointer const_pointer; + typedef typename + boost::detail::allocator::rebind_to< + Allocator,pointer + >::type::pointer ptr_pointer; ptr_pointer& up(){return up_;} ptr_pointer up()const{return up_;} @@ -181,25 +174,19 @@ struct random_access_index_node_impl template struct random_access_index_node_trampoline: - prevent_eti< - Super, - random_access_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type + random_access_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > { - typedef typename prevent_eti< - Super, - random_access_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type impl_type; + typedef random_access_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > impl_type; }; template diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ops.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ops.hpp index 5bf1ade7f..6cb030fbc 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ops.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ops.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2009 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP #define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -30,8 +30,7 @@ namespace detail{ template Node* random_access_index_remove( - random_access_index_ptr_array& ptrs,Predicate pred - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node)) + random_access_index_ptr_array& ptrs,Predicate pred) { typedef typename Node::value_type value_type; typedef typename Node::impl_ptr_pointer impl_ptr_pointer; @@ -55,8 +54,7 @@ Node* random_access_index_remove( template Node* random_access_index_unique( - random_access_index_ptr_array& ptrs,BinaryPredicate binary_pred - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node)) + random_access_index_ptr_array& ptrs,BinaryPredicate binary_pred) { typedef typename Node::value_type value_type; typedef typename Node::impl_ptr_pointer impl_ptr_pointer; @@ -86,8 +84,7 @@ template void random_access_index_inplace_merge( const Allocator& al, random_access_index_ptr_array& ptrs, - BOOST_DEDUCED_TYPENAME Node::impl_ptr_pointer first1,Compare comp - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node)) + BOOST_DEDUCED_TYPENAME Node::impl_ptr_pointer first1,Compare comp) { typedef typename Node::value_type value_type; typedef typename Node::impl_pointer impl_pointer; @@ -151,8 +148,7 @@ template void random_access_index_sort( const Allocator& al, random_access_index_ptr_array& ptrs, - Compare comp - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node)) + Compare comp) { /* The implementation is extremely simple: an auxiliary * array of pointers is sorted using stdlib facilities and diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ptr_array.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ptr_array.hpp index c1d9873f5..bae1c851b 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ptr_array.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_index_ptr_array.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP #define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -17,7 +17,6 @@ #include #include #include -#include #include #include #include @@ -33,29 +32,23 @@ namespace detail{ template class random_access_index_ptr_array:private noncopyable { - typedef typename prevent_eti< - Allocator, - random_access_index_node_impl< - typename boost::detail::allocator::rebind_to< - Allocator, - char - >::type - > - >::type node_impl_type; - -public: - typedef typename node_impl_type::pointer value_type; - typedef typename prevent_eti< - Allocator, + typedef random_access_index_node_impl< typename boost::detail::allocator::rebind_to< - Allocator,value_type + Allocator, + char >::type - >::type::pointer pointer; + > node_impl_type; + +public: + typedef typename node_impl_type::pointer value_type; + typedef typename boost::detail::allocator::rebind_to< + Allocator,value_type + >::type::pointer pointer; random_access_index_ptr_array( - const Allocator& al,value_type end_,std::size_t size): - size_(size), - capacity_(size), + const Allocator& al,value_type end_,std::size_t sz): + size_(sz), + capacity_(sz), spc(al,capacity_+1) { *end()=end_; diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_node_iterator.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_node_iterator.hpp index 5ae3286dd..65bf5e8e0 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_node_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/rnd_node_iterator.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP #define BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/safe_ctr_proxy.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/safe_ctr_proxy.hpp deleted file mode 100644 index c733f968a..000000000 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/safe_ctr_proxy.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. - * 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/multi_index for library home page. - */ - -#ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_CTR_PROXY_HPP -#define BOOST_MULTI_INDEX_DETAIL_SAFE_CTR_PROXY_HPP - -#if defined(_MSC_VER)&&(_MSC_VER>=1200) -#pragma once -#endif - -#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#include /* keep it first to prevent nasty warns in MSVC */ -#include - -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) -#include - -namespace boost{ - -namespace multi_index{ - -namespace detail{ - -/* A safe iterator is instantiated in the form - * safe_iterator: MSVC++ 6.0 has serious troubles with - * the resulting symbols names, given that index names (which stand for - * Container) are fairly long themselves. safe_ctr_proxy does not statically - * depend on Container, and provides the necessary methods (begin and end) to - * the safe mode framework via an abstract interface. With safe_ctr_proxy, - * instead of deriving from safe_container the following base class - * must be used: - * - * safe_ctr_proxy_impl - * - * where Iterator is the type of the *unsafe* iterator being wrapped. - * The corresponding safe iterator instantiation is then - * - * safe_iterator >, - * - * which does not include the name of Container. - */ - -template -class safe_ctr_proxy: - public safe_mode::safe_container > -{ -public: - typedef safe_mode::safe_iterator iterator; - typedef iterator const_iterator; - - iterator begin(){return begin_impl();} - const_iterator begin()const{return begin_impl();} - iterator end(){return end_impl();} - const_iterator end()const{return end_impl();} - -protected: - virtual iterator begin_impl()=0; - virtual const_iterator begin_impl()const=0; - virtual iterator end_impl()=0; - virtual const_iterator end_impl()const=0; -}; - -template -class safe_ctr_proxy_impl:public safe_ctr_proxy -{ - typedef safe_ctr_proxy super; - typedef Container container_type; - -public: - typedef typename super::iterator iterator; - typedef typename super::const_iterator const_iterator; - - virtual iterator begin_impl(){return container().begin();} - virtual const_iterator begin_impl()const{return container().begin();} - virtual iterator end_impl(){return container().end();} - virtual const_iterator end_impl()const{return container().end();} - -private: - container_type& container() - { - return *static_cast(this); - } - - const container_type& container()const - { - return *static_cast(this); - } -}; - -} /* namespace multi_index::detail */ - -} /* namespace multi_index */ - -} /* namespace boost */ - -#endif /* workaround */ - -#endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */ - -#endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/safe_mode.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/safe_mode.hpp index 4e4a58527..905270e9f 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/safe_mode.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/safe_mode.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP #define BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -116,6 +116,7 @@ #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) #include +#include #endif #if defined(BOOST_HAS_THREADS) @@ -567,6 +568,19 @@ class safe_container:public detail::safe_container_base } /* namespace multi_index */ +#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) +namespace serialization{ +template +struct version< + boost::multi_index::safe_mode::safe_iterator +> +{ + BOOST_STATIC_CONSTANT( + int,value=boost::serialization::version::value); +}; +} /* namespace serialization */ +#endif + } /* namespace boost */ #endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */ diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/scope_guard.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/scope_guard.hpp index c64429e57..116f8f504 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/scope_guard.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/scope_guard.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP #define BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_node.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_node.hpp index cf409ed0b..5cb467650 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_node.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_node.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,14 +9,13 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP #define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif #include /* keep it first to prevent nasty warns in MSVC */ #include #include -#include namespace boost{ @@ -29,18 +28,14 @@ namespace detail{ template struct sequenced_index_node_impl { - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,sequenced_index_node_impl - >::type - >::type::pointer pointer; - typedef typename prevent_eti< - Allocator, - typename boost::detail::allocator::rebind_to< - Allocator,sequenced_index_node_impl - >::type - >::type::const_pointer const_pointer; + typedef typename + boost::detail::allocator::rebind_to< + Allocator,sequenced_index_node_impl + >::type::pointer pointer; + typedef typename + boost::detail::allocator::rebind_to< + Allocator,sequenced_index_node_impl + >::type::const_pointer const_pointer; pointer& prior(){return prior_;} pointer prior()const{return prior_;} @@ -136,25 +131,19 @@ struct sequenced_index_node_impl template struct sequenced_index_node_trampoline: - prevent_eti< - Super, - sequenced_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type + sequenced_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > { - typedef typename prevent_eti< - Super, - sequenced_index_node_impl< - typename boost::detail::allocator::rebind_to< - typename Super::allocator_type, - char - >::type - > - >::type impl_type; + typedef sequenced_index_node_impl< + typename boost::detail::allocator::rebind_to< + typename Super::allocator_type, + char + >::type + > impl_type; }; template diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_ops.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_ops.hpp index 8135074c2..56da40834 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_ops.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/seq_index_ops.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP #define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -79,8 +79,7 @@ template void sequenced_index_collate( BOOST_DEDUCED_TYPENAME Node::impl_type* x, BOOST_DEDUCED_TYPENAME Node::impl_type* y, - Compare comp - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node)) + Compare comp) { typedef typename Node::impl_type impl_type; typedef typename Node::impl_pointer impl_pointer; diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/serialization_version.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/serialization_version.hpp index cced78c1f..ccd8bb4f7 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/serialization_version.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/serialization_version.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2010 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP #define BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -60,7 +60,6 @@ struct serialization_version } /* namespace multi_index */ -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace serialization { template struct version > @@ -68,7 +67,6 @@ struct version > BOOST_STATIC_CONSTANT(int,value=version::value); }; } /* namespace serialization */ -#endif } /* namespace boost */ diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/uintptr_type.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/uintptr_type.hpp index 529c62315..9c92d01d4 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/uintptr_type.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/uintptr_type.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP #define BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/unbounded.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/unbounded.hpp index 40c303445..dc09be177 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/unbounded.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/unbounded.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP #define BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -22,22 +22,6 @@ namespace multi_index{ /* dummy type and variable for use in ordered_index::range() */ -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) -/* The default branch actually works for MSVC 6.0, but seems like - * this implementation of unbounded improves the performance of ordered - * indices! This behavior is hard to explain and probably a test artifact, - * but it does not hurt to have the workaround anyway. - */ - -namespace detail{struct unbounded_type{};} - -namespace{ - -static detail::unbounded_type unbounded_obj=detail::unbounded_type(); -static detail::unbounded_type& unbounded=unbounded_obj; - -} /* unnamed */ -#else /* ODR-abiding technique shown at the example attached to * http://lists.boost.org/Archives/boost/2006/07/108355.php */ @@ -63,7 +47,6 @@ inline detail::unbounded_helper unbounded(detail::unbounded_helper) { return detail::unbounded_helper(); } -#endif /* tags used in the implementation of range */ diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/value_compare.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/value_compare.hpp index 0bd7b4f2d..1fde20549 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/value_compare.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/value_compare.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP #define BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/detail/vartempl_support.hpp b/src/thirdparty/boost_lib/boost/multi_index/detail/vartempl_support.hpp index f6db6bf29..06ff430f4 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/detail/vartempl_support.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/detail/vartempl_support.hpp @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP #define BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/global_fun.hpp b/src/thirdparty/boost_lib/boost/multi_index/global_fun.hpp index 8520e4d0c..9333f5891 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/global_fun.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/global_fun.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_GLOBAL_FUN_HPP #define BOOST_MULTI_INDEX_GLOBAL_FUN_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -46,16 +46,6 @@ namespace detail{ * arbitrary combinations of these (vg. T** or auto_ptr.) */ -/* NB. Some overloads of operator() have an extra dummy parameter int=0. - * This disambiguator serves several purposes: - * - Without it, MSVC++ 6.0 incorrectly regards some overloads as - * specializations of a previous member function template. - * - MSVC++ 6.0/7.0 seem to incorrectly treat some different memfuns - * as if they have the same signature. - * - If remove_const is broken due to lack of PTS, int=0 avoids the - * declaration of memfuns with identical signature. - */ - template struct const_ref_global_fun_base { @@ -90,7 +80,7 @@ struct const_ref_global_fun_base Type operator()( const reference_wrapper< typename remove_const< - typename remove_reference::type>::type>& x,int=0)const + typename remove_reference::type>::type>& x)const { return operator()(x.get()); } @@ -158,8 +148,7 @@ struct non_ref_global_fun_base } Type operator()( - const reference_wrapper< - typename remove_const::type>& x,int=0)const + const reference_wrapper::type>& x)const { return operator()(x.get()); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/hashed_index.hpp b/src/thirdparty/boost_lib/boost/multi_index/hashed_index.hpp index ef02eb16e..ebf55c9ef 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/hashed_index.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/hashed_index.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2013 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_HASHED_INDEX_HPP #define BOOST_MULTI_INDEX_HASHED_INDEX_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -31,14 +32,16 @@ #include #include #include -#include #include #include #include #include #include +#include +#include #include #include +#include #include #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) @@ -71,12 +74,9 @@ namespace detail{ /* Most of the implementation of unique and non-unique indices is * shared. We tell from one another on instantiation time by using - * these tags. + * Category tags defined in hash_index_node.hpp. */ -struct hashed_unique_tag{}; -struct hashed_non_unique_tag{}; - template< typename KeyFromValue,typename Hash,typename Pred, typename SuperMeta,typename TagList,typename Category @@ -85,17 +85,9 @@ class hashed_index: BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - ,public safe_ctr_proxy_impl< - hashed_index_iterator< - hashed_index_node, - bucket_array >, - hashed_index > -#else ,public safe_mode::safe_container< hashed_index > #endif -#endif { #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ @@ -112,11 +104,13 @@ class hashed_index: protected: typedef hashed_index_node< - typename super::node_type> node_type; + typename super::node_type,Category> node_type; private: + typedef typename node_type::node_alg node_alg; typedef typename node_type::impl_type node_impl_type; typedef typename node_impl_type::pointer node_impl_pointer; + typedef typename node_impl_type::base_pointer node_impl_base_pointer; typedef bucket_array< typename super::final_allocator_type> bucket_array_type; @@ -139,28 +133,24 @@ class hashed_index: typedef std::ptrdiff_t difference_type; #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_mode::safe_iterator< - hashed_index_iterator< - node_type,bucket_array_type>, - safe_ctr_proxy< - hashed_index_iterator< - node_type,bucket_array_type> > > iterator; -#else typedef safe_mode::safe_iterator< hashed_index_iterator< - node_type,bucket_array_type>, + node_type,bucket_array_type, + hashed_index_global_iterator_tag>, hashed_index> iterator; -#endif #else typedef hashed_index_iterator< - node_type,bucket_array_type> iterator; + node_type,bucket_array_type, + hashed_index_global_iterator_tag> iterator; #endif typedef iterator const_iterator; - typedef iterator local_iterator; - typedef const_iterator const_local_iterator; + typedef hashed_index_iterator< + node_type,bucket_array_type, + hashed_index_local_iterator_tag> local_iterator; + typedef local_iterator const_local_iterator; + typedef TagList tag_list; protected: @@ -186,15 +176,8 @@ class hashed_index: private: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_ctr_proxy_impl< - hashed_index_iterator< - node_type,bucket_array_type>, - hashed_index> safe_super; -#else typedef safe_mode::safe_container< hashed_index> safe_super; -#endif #endif typedef typename call_traits::param_type value_param_type; @@ -230,36 +213,27 @@ class hashed_index: } #endif - allocator_type get_allocator()const + allocator_type get_allocator()const BOOST_NOEXCEPT { return this->final().get_allocator(); } /* size and capacity */ - bool empty()const{return this->final_empty_();} - size_type size()const{return this->final_size_();} - size_type max_size()const{return this->final_max_size_();} + bool empty()const BOOST_NOEXCEPT{return this->final_empty_();} + size_type size()const BOOST_NOEXCEPT{return this->final_size_();} + size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();} /* iterators */ - iterator begin() - { - return make_iterator( - node_type::from_impl(buckets.at(first_bucket)->next())); - } - - const_iterator begin()const - { - return make_iterator( - node_type::from_impl(buckets.at(first_bucket)->next())); - } - - iterator end(){return make_iterator(header());} - const_iterator end()const{return make_iterator(header());} - - const_iterator cbegin()const{return begin();} - const_iterator cend()const{return end();} + iterator begin()BOOST_NOEXCEPT + {return make_iterator(node_type::from_impl(header()->next()->prior()));} + const_iterator begin()const BOOST_NOEXCEPT + {return make_iterator(node_type::from_impl(header()->next()->prior()));} + iterator end()BOOST_NOEXCEPT{return make_iterator(header());} + const_iterator end()const BOOST_NOEXCEPT{return make_iterator(header());} + const_iterator cbegin()const BOOST_NOEXCEPT{return begin();} + const_iterator cend()const BOOST_NOEXCEPT{return end();} iterator iterator_to(const value_type& x) { @@ -341,28 +315,23 @@ class hashed_index: { BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT; - size_type s=0; - std::size_t buc=buckets.position(hash_(k)); - node_impl_pointer x=buckets.at(buc); - node_impl_pointer y=x->next(); - while(y!=x){ - if(eq_(k,key(node_type::from_impl(y)->value()))){ - bool b; + std::size_t buc=buckets.position(hash_(k)); + for(node_impl_pointer x=buckets.at(buc)->prior(); + x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){ + if(eq_(k,key(node_type::from_impl(x)->value()))){ + node_impl_pointer y=end_of_range(x); + size_type s=0; do{ - node_impl_pointer z=y->next(); - b=z!=x&&eq_( - key(node_type::from_impl(y)->value()), - key(node_type::from_impl(z)->value())); + node_impl_pointer z=node_alg::after(x); this->final_erase_( - static_cast(node_type::from_impl(y))); - y=z; + static_cast(node_type::from_impl(x))); + x=z; ++s; - }while(b); - break; + }while(x!=y); + return s; } - y=y->next(); } - return s; + return 0; } iterator erase(iterator first,iterator last) @@ -421,7 +390,7 @@ class hashed_index: } template - bool modify(iterator position,Modifier mod,Rollback back) + bool modify(iterator position,Modifier mod,Rollback back_) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); @@ -438,7 +407,7 @@ class hashed_index: #endif return this->final_modify_( - mod,back,static_cast(position.get_node())); + mod,back_,static_cast(position.get_node())); } template @@ -453,7 +422,7 @@ class hashed_index: } template - bool modify_key(iterator position,Modifier mod,Rollback back) + bool modify_key(iterator position,Modifier mod,Rollback back_) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); @@ -462,10 +431,10 @@ class hashed_index: return modify( position, modify_key_adaptor(mod,key), - modify_key_adaptor(back,key)); + modify_key_adaptor(back_,key)); } - void clear() + void clear()BOOST_NOEXCEPT { BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT; this->final_clear_(); @@ -503,14 +472,12 @@ class hashed_index: const CompatibleKey& k, const CompatibleHash& hash,const CompatiblePred& eq)const { - std::size_t buc=buckets.position(hash(k)); - node_impl_pointer x=buckets.at(buc); - node_impl_pointer y=x->next(); - while(y!=x){ - if(eq(k,key(node_type::from_impl(y)->value()))){ - return make_iterator(node_type::from_impl(y)); + std::size_t buc=buckets.position(hash(k)); + for(node_impl_pointer x=buckets.at(buc)->prior(); + x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){ + if(eq(k,key(node_type::from_impl(x)->value()))){ + return make_iterator(node_type::from_impl(x)); } - y=y->next(); } return end(); } @@ -528,21 +495,20 @@ class hashed_index: const CompatibleKey& k, const CompatibleHash& hash,const CompatiblePred& eq)const { - size_type res=0; - std::size_t buc=buckets.position(hash(k)); - node_impl_pointer x=buckets.at(buc); - node_impl_pointer y=x->next(); - while(y!=x){ - if(eq(k,key(node_type::from_impl(y)->value()))){ + std::size_t buc=buckets.position(hash(k)); + for(node_impl_pointer x=buckets.at(buc)->prior(); + x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){ + if(eq(k,key(node_type::from_impl(x)->value()))){ + size_type res=0; + node_impl_pointer y=end_of_range(x); do{ ++res; - y=y->next(); - }while(y!=x&&eq(k,key(node_type::from_impl(y)->value()))); - break; + x=node_alg::after(x); + }while(x!=y); + return res; } - y=y->next(); } - return res; + return 0; } template @@ -558,43 +524,29 @@ class hashed_index: const CompatibleKey& k, const CompatibleHash& hash,const CompatiblePred& eq)const { - std::size_t buc=buckets.position(hash(k)); - node_impl_pointer x=buckets.at(buc); - node_impl_pointer y=x->next(); - while(y!=x){ - if(eq(k,key(node_type::from_impl(y)->value()))){ - node_impl_pointer y0=y; - do{ - y=y->next(); - }while(y!=x&&eq(k,key(node_type::from_impl(y)->value()))); - if(y==x){ - do{ - ++y; - }while(y==y->next()); - y=y->next(); - } + std::size_t buc=buckets.position(hash(k)); + for(node_impl_pointer x=buckets.at(buc)->prior(); + x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){ + if(eq(k,key(node_type::from_impl(x)->value()))){ return std::pair( - make_iterator(node_type::from_impl(y0)), - make_iterator(node_type::from_impl(y))); + make_iterator(node_type::from_impl(x)), + make_iterator(node_type::from_impl(end_of_range(x)))); } - y=y->next(); } return std::pair(end(),end()); } /* bucket interface */ - size_type bucket_count()const{return buckets.size();} - size_type max_bucket_count()const{return static_cast(-1);} + size_type bucket_count()const BOOST_NOEXCEPT{return buckets.size();} + size_type max_bucket_count()const BOOST_NOEXCEPT{return static_cast(-1);} size_type bucket_size(size_type n)const { - size_type res=0; - node_impl_pointer x=buckets.at(n); - node_impl_pointer y=x->next(); - while(y!=x){ + size_type res=0; + for(node_impl_pointer x=buckets.at(n)->prior(); + x!=node_impl_pointer(0);x=node_alg::after_local(x)){ ++res; - y=y->next(); } return res; } @@ -611,10 +563,9 @@ class hashed_index: const_local_iterator begin(size_type n)const { - node_impl_pointer x=buckets.at(n); - node_impl_pointer y=x->next(); - if(y==x)return end(); - return make_iterator(node_type::from_impl(y)); + node_impl_pointer x=buckets.at(n)->prior(); + if(x==node_impl_pointer(0))return end(n); + return make_local_iterator(node_type::from_impl(x)); } local_iterator end(size_type n) @@ -622,14 +573,9 @@ class hashed_index: return const_cast(this)->end(n); } - const_local_iterator end(size_type n)const + const_local_iterator end(size_type)const { - node_impl_pointer x=buckets.at(n); - if(x==x->next())return end(); - do{ - ++x; - }while(x==x->next()); - return make_iterator(node_type::from_impl(x->next())); + return make_local_iterator(0); } const_local_iterator cbegin(size_type n)const{return begin(n);} @@ -637,24 +583,25 @@ class hashed_index: local_iterator local_iterator_to(const value_type& x) { - return make_iterator(node_from_value(&x)); + return make_local_iterator(node_from_value(&x)); } const_local_iterator local_iterator_to(const value_type& x)const { - return make_iterator(node_from_value(&x)); + return make_local_iterator(node_from_value(&x)); } /* hash policy */ - float load_factor()const{return static_cast(size())/bucket_count();} - float max_load_factor()const{return mlf;} + float load_factor()const BOOST_NOEXCEPT + {return static_cast(size())/bucket_count();} + float max_load_factor()const BOOST_NOEXCEPT{return mlf;} void max_load_factor(float z){mlf=z;calculate_max_load();} void rehash(size_type n) { BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT; - if(size()::max)(); float fbc=static_cast(1+size()/mlf); @@ -665,6 +612,11 @@ class hashed_index: unchecked_rehash(bc); } + void reserve(size_type n) + { + rehash(static_cast(std::ceil(static_cast(n)/mlf))); + } + BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS: hashed_index(const ctor_args_list& args_list,const allocator_type& al): super(args_list.get_tail(),al), @@ -672,8 +624,7 @@ class hashed_index: hash_(tuples::get<2>(args_list.get_head())), eq_(tuples::get<3>(args_list.get_head())), buckets(al,header()->impl(),tuples::get<0>(args_list.get_head())), - mlf(1.0f), - first_bucket(buckets.size()) + mlf(1.0f) { calculate_max_load(); } @@ -691,8 +642,7 @@ class hashed_index: eq_(x.eq_), buckets(x.get_allocator(),header()->impl(),x.buckets.size()), mlf(x.mlf), - max_load(x.max_load), - first_bucket(x.first_bucket) + max_load(x.max_load) { /* Copy ctor just takes the internal configuration objects from x. The rest * is done in subsequent call to copy_(). @@ -712,8 +662,7 @@ class hashed_index: hash_(x.hash_), eq_(x.eq_), buckets(x.get_allocator(),header()->impl(),0), - mlf(1.0f), - first_bucket(buckets.size()) + mlf(1.0f) { calculate_max_load(); } @@ -726,94 +675,163 @@ class hashed_index: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) iterator make_iterator(node_type* node) { - return iterator(node,&buckets,this); + return iterator(node,this); } const_iterator make_iterator(node_type* node)const { - return const_iterator( - node, - &const_cast(buckets), - const_cast(this)); + return const_iterator(node,const_cast(this)); } #else iterator make_iterator(node_type* node) { - return iterator(node,&buckets); + return iterator(node); } const_iterator make_iterator(node_type* node)const { - return const_iterator(node,&const_cast(buckets)); + return const_iterator(node); } #endif + local_iterator make_local_iterator(node_type* node) + { + return local_iterator(node); + } + + const_local_iterator make_local_iterator(node_type* node)const + { + return const_local_iterator(node); + } + void copy_( const hashed_index& x, const copy_map_type& map) { - for(node_impl_pointer begin_org=x.buckets.begin(), - begin_cpy=buckets.begin(), - end_org=x.buckets.end(); - begin_org!=end_org;++begin_org,++begin_cpy){ - - node_impl_pointer next_org=begin_org->next(); - node_impl_pointer cpy=begin_cpy; - while(next_org!=begin_org){ - cpy->next()= - static_cast( - map.find( - static_cast( - node_type::from_impl(next_org))))->impl(); - next_org=next_org->next(); - cpy=cpy->next(); - } - cpy->next()=begin_cpy; + copy_(x,map,Category()); + } + + void copy_( + const hashed_index& x, + const copy_map_type& map,hashed_unique_tag) + { + if(x.size()!=0){ + node_impl_pointer end_org=x.header()->impl(), + org=end_org, + cpy=header()->impl(); + do{ + node_impl_pointer prev_org=org->prior(), + prev_cpy= + static_cast(map.find(static_cast( + node_type::from_impl(prev_org))))->impl(); + cpy->prior()=prev_cpy; + if(node_alg::is_first_of_bucket(org)){ + node_impl_base_pointer buc_org=prev_org->next(), + buc_cpy= + buckets.begin()+(buc_org-x.buckets.begin()); + prev_cpy->next()=buc_cpy; + buc_cpy->prior()=cpy; + } + else{ + prev_cpy->next()=node_impl_type::base_pointer_from(cpy); + } + org=prev_org; + cpy=prev_cpy; + }while(org!=end_org); } super::copy_(x,map); } + void copy_( + const hashed_index& x, + const copy_map_type& map,hashed_non_unique_tag) + { + if(x.size()!=0){ + node_impl_pointer end_org=x.header()->impl(), + org=end_org, + cpy=header()->impl(); + do{ + node_impl_pointer next_org=node_alg::after(org), + next_cpy= + static_cast(map.find(static_cast( + node_type::from_impl(next_org))))->impl(); + if(node_alg::is_first_of_bucket(next_org)){ + node_impl_base_pointer buc_org=org->next(), + buc_cpy= + buckets.begin()+(buc_org-x.buckets.begin()); + cpy->next()=buc_cpy; + buc_cpy->prior()=next_cpy; + next_cpy->prior()=cpy; + } + else{ + if(org->next()==node_impl_type::base_pointer_from(next_org)){ + cpy->next()=node_impl_type::base_pointer_from(next_cpy); + } + else{ + cpy->next()= + node_impl_type::base_pointer_from( + static_cast(map.find(static_cast( + node_type::from_impl( + node_impl_type::pointer_from(org->next())))))->impl()); + } + + if(next_org->prior()!=org){ + next_cpy->prior()= + static_cast(map.find(static_cast( + node_type::from_impl(next_org->prior()))))->impl(); + } + else{ + next_cpy->prior()=cpy; + } + } + org=next_org; + cpy=next_cpy; + }while(org!=end_org); + } + + super::copy_(x,map); + } + template - node_type* insert_(value_param_type v,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,final_node_type*& x,Variant variant) { - reserve(size()+1); + reserve_for_insert(size()+1); - std::size_t buc=find_bucket(v); - node_impl_pointer pos=buckets.at(buc); - if(!link_point(v,pos,Category()))return node_type::from_impl(pos); - - node_type* res=static_cast(super::insert_(v,x,variant)); - if(res==x){ - link(x,pos); - if(first_bucket>buc)first_bucket=buc; + std::size_t buc=find_bucket(v); + link_info pos(buckets.at(buc)); + if(!link_point(v,pos)){ + return static_cast( + node_type::from_impl(node_impl_type::pointer_from(pos))); } + + final_node_type* res=super::insert_(v,x,variant); + if(res==x)link(static_cast(x),pos); return res; } template - node_type* insert_( - value_param_type v,node_type* position,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,node_type* position,final_node_type*& x,Variant variant) { - reserve(size()+1); - - std::size_t buc=find_bucket(v); - node_impl_pointer pos=buckets.at(buc); - if(!link_point(v,pos,Category()))return node_type::from_impl(pos); + reserve_for_insert(size()+1); - node_type* res= - static_cast(super::insert_(v,position,x,variant)); - if(res==x){ - link(x,pos); - if(first_bucket>buc)first_bucket=buc; + std::size_t buc=find_bucket(v); + link_info pos(buckets.at(buc)); + if(!link_point(v,pos)){ + return static_cast( + node_type::from_impl(node_impl_type::pointer_from(pos))); } + + final_node_type* res=super::insert_(v,position,x,variant); + if(res==x)link(static_cast(x),pos); return res; } void erase_(node_type* x) { unlink(x); - first_bucket=buckets.first_nonempty(first_bucket); super::erase_(x); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) @@ -823,23 +841,42 @@ class hashed_index: void delete_all_nodes_() { - for(node_impl_pointer x=buckets.begin(),x_end=buckets.end(); - x!=x_end;++x){ - node_impl_pointer y=x->next(); - while(y!=x){ - node_impl_pointer z=y->next(); - this->final_delete_node_( - static_cast(node_type::from_impl(y))); - y=z; + delete_all_nodes_(Category()); + } + + void delete_all_nodes_(hashed_unique_tag) + { + for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){ + node_impl_pointer y=x->prior(); + this->final_delete_node_( + static_cast(node_type::from_impl(x))); + x=y; + } + } + + void delete_all_nodes_(hashed_non_unique_tag) + { + for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){ + node_impl_pointer y=x->prior(); + if(y->next()!=node_impl_type::base_pointer_from(x)&& + y->next()->prior()!=x){ /* n-1 of group */ + /* Make the second node prior() pointer back-linked so that it won't + * refer to a deleted node when the time for its own destruction comes. + */ + + node_impl_pointer first=node_impl_type::pointer_from(y->next()); + first->next()->prior()=first; } + this->final_delete_node_( + static_cast(node_type::from_impl(x))); + x=y; } } void clear_() { super::clear_(); - buckets.clear(); - first_bucket=buckets.size(); + buckets.clear(header()->impl()); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) safe_super::detach_dereferenceable_iterators(); @@ -855,7 +892,6 @@ class hashed_index: buckets.swap(x.buckets); std::swap(mlf,x.mlf); std::swap(max_load,x.max_load); - std::swap(first_bucket,x.first_bucket); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) safe_super::swap(x); @@ -870,7 +906,6 @@ class hashed_index: buckets.swap(x.buckets); std::swap(mlf,x.mlf); std::swap(max_load,x.max_load); - std::swap(first_bucket,x.first_bucket); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) safe_super::swap(x); @@ -885,28 +920,22 @@ class hashed_index: if(eq_(key(v),key(x->value()))){ return super::replace_(v,x,variant); } - - node_impl_pointer y=prev(x); - unlink_next(y); + + unlink_undo undo; + unlink(x,undo); BOOST_TRY{ - std::size_t buc=find_bucket(v); - node_impl_pointer pos=buckets.at(buc); - if(link_point(v,pos,Category())&&super::replace_(v,x,variant)){ + std::size_t buc=find_bucket(v); + link_info pos(buckets.at(buc)); + if(link_point(v,pos)&&super::replace_(v,x,variant)){ link(x,pos); - if(first_bucket>buc){ - first_bucket=buc; - } - else if(first_bucketvalue()); - b=in_place(x->impl(),key(x->value()),buc,Category()); + b=in_place(x->impl(),key(x->value()),buc); } BOOST_CATCH(...){ erase_(x); @@ -928,9 +957,8 @@ class hashed_index: if(!b){ unlink(x); BOOST_TRY{ - node_impl_pointer pos=buckets.at(buc); - if(!link_point(x->value(),pos,Category())){ - first_bucket=buckets.first_nonempty(first_bucket); + link_info pos(buckets.at(buc)); + if(!link_point(x->value(),pos)){ super::erase_(x); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) @@ -939,15 +967,8 @@ class hashed_index: return false; } link(x,pos); - if(first_bucket>buc){ - first_bucket=buc; - } - else if(first_bucketvalue()); - if(in_place(x->impl(),key(x->value()),buc,Category())){ + if(in_place(x->impl(),key(x->value()),buc)){ return super::modify_rollback_(x); } - node_impl_pointer y=prev(x); - unlink_next(y); + unlink_undo undo; + unlink(x,undo); BOOST_TRY{ - node_impl_pointer pos=buckets.at(buc); - if(link_point(x->value(),pos,Category())&&super::modify_rollback_(x)){ + link_info pos(buckets.at(buc)); + if(link_point(x->value(),pos)&&super::modify_rollback_(x)){ link(x,pos); - if(first_bucket>buc){ - first_bucket=buc; - } - else if(first_bucket + friend bool operator==( + const hashed_index&,const hashed_index& y); +#endif + + bool equals(const hashed_index& x)const{return equals(x,Category());} + + bool equals(const hashed_index& x,hashed_unique_tag)const + { + if(size()!=x.size())return false; + for(const_iterator it=begin(),it_end=end(),it2_end=x.end(); + it!=it_end;++it){ + const_iterator it2=x.find(key(*it)); + if(it2==it2_end||!(*it==*it2))return false; + } + return true; + } + + bool equals(const hashed_index& x,hashed_non_unique_tag)const + { + if(size()!=x.size())return false; + for(const_iterator it=begin(),it_end=end();it!=it_end;){ + const_iterator it2,it2_last; + boost::tie(it2,it2_last)=x.equal_range(key(*it)); + if(it2==it2_last)return false; + + const_iterator it_last=make_iterator( + node_type::from_impl(end_of_range(it.get_node()->impl()))); + if(std::distance(it,it_last)!=std::distance(it2,it2_last))return false; + + /* From is_permutation code in + * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf + */ + + for(;it!=it_last;++it,++it2){ + if(!(*it==*it2))break; + } + if(it!=it_last){ + for(const_iterator scan=it;scan!=it_last;++scan){ + if(std::find(it,scan,*scan)!=scan)continue; + std::ptrdiff_t matches=std::count(it2,it2_last,*scan); + if(matches==0||matches!=std::count(scan,it_last,*scan))return false; + } + it=it_last; + } + } + return true; + } + #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) /* serialization */ @@ -1060,8 +1128,6 @@ class hashed_index: if(s1!=size())return false; } - if(first_bucket!=buckets.first_nonempty(0))return false; - return super::invariant_(); } @@ -1080,64 +1146,147 @@ class hashed_index: return bucket(key(v)); } + struct link_info_non_unique + { + link_info_non_unique(node_impl_base_pointer pos): + first(pos),last(node_impl_base_pointer(0)){} + + operator const node_impl_base_pointer&()const{return this->first;} + + node_impl_base_pointer first,last; + }; + + typedef typename mpl::if_< + is_same, + node_impl_base_pointer, + link_info_non_unique + >::type link_info; + + bool link_point(value_param_type v,link_info& pos) + { + return link_point(v,pos,Category()); + } + bool link_point( - value_param_type v,node_impl_pointer& pos,hashed_unique_tag) + value_param_type v,node_impl_base_pointer& pos,hashed_unique_tag) { - node_impl_pointer x=pos->next(); - while(x!=pos){ + for(node_impl_pointer x=pos->prior();x!=node_impl_pointer(0); + x=node_alg::after_local(x)){ if(eq_(key(v),key(node_type::from_impl(x)->value()))){ - pos=x; + pos=node_impl_type::base_pointer_from(x); return false; } - x=x->next(); } return true; } bool link_point( - value_param_type v,node_impl_pointer& pos,hashed_non_unique_tag) + value_param_type v,link_info_non_unique& pos,hashed_non_unique_tag) { - node_impl_pointer prev=pos; - node_impl_pointer x=pos->next(); - while(x!=pos){ + for(node_impl_pointer x=pos.first->prior();x!=node_impl_pointer(0); + x=node_alg::next_to_inspect(x)){ if(eq_(key(v),key(node_type::from_impl(x)->value()))){ - pos=prev; + pos.first=node_impl_type::base_pointer_from(x); + pos.last=node_impl_type::base_pointer_from(last_of_range(x)); return true; } - prev=x; - x=x->next(); } return true; } - - static void link(node_type* x,node_impl_pointer pos) + + node_impl_pointer last_of_range(node_impl_pointer x)const { - node_impl_type::link(x->impl(),pos); - }; + return last_of_range(x,Category()); + } - static void link(node_impl_pointer x,node_impl_pointer pos) + node_impl_pointer last_of_range(node_impl_pointer x,hashed_unique_tag)const { - node_impl_type::link(x,pos); - }; + return x; + } - static void unlink(node_type* x) + node_impl_pointer last_of_range( + node_impl_pointer x,hashed_non_unique_tag)const { - node_impl_type::unlink(x->impl()); - }; + node_impl_base_pointer y=x->next(); + node_impl_pointer z=y->prior(); + if(z==x){ /* range of size 1 or 2 */ + node_impl_pointer yy=node_impl_type::pointer_from(y); + return + eq_( + key(node_type::from_impl(x)->value()), + key(node_type::from_impl(yy)->value()))?yy:x; + } + else if(z->prior()==x) /* last of bucket */ + return x; + else /* group of size>2 */ + return z; + } + + node_impl_pointer end_of_range(node_impl_pointer x)const + { + return end_of_range(x,Category()); + } + + node_impl_pointer end_of_range(node_impl_pointer x,hashed_unique_tag)const + { + return node_alg::after(last_of_range(x)); + } + + node_impl_pointer end_of_range( + node_impl_pointer x,hashed_non_unique_tag)const + { + node_impl_base_pointer y=x->next(); + node_impl_pointer z=y->prior(); + if(z==x){ /* range of size 1 or 2 */ + node_impl_pointer yy=node_impl_type::pointer_from(y); + if(!eq_( + key(node_type::from_impl(x)->value()), + key(node_type::from_impl(yy)->value())))yy=x; + return yy->next()->prior()==yy? + node_impl_type::pointer_from(yy->next()): + yy->next()->prior(); + } + else if(z->prior()==x) /* last of bucket */ + return z; + else /* group of size>2 */ + return z->next()->prior()==z? + node_impl_type::pointer_from(z->next()): + z->next()->prior(); + } + + void link(node_type* x,const link_info& pos) + { + link(x,pos,Category()); + } + + void link(node_type* x,node_impl_base_pointer pos,hashed_unique_tag) + { + node_alg::link(x->impl(),pos,header()->impl()); + } - static node_impl_pointer prev(node_type* x) + void link(node_type* x,const link_info_non_unique& pos,hashed_non_unique_tag) { - return node_impl_type::prev(x->impl()); + if(pos.last==node_impl_base_pointer(0)){ + node_alg::link(x->impl(),pos.first,header()->impl()); + } + else{ + node_alg::link( + x->impl(), + node_impl_type::pointer_from(pos.first), + node_impl_type::pointer_from(pos.last)); + } } - static node_impl_pointer prev_from(node_type* x,node_impl_pointer y) + void unlink(node_type* x) { - return node_impl_type::prev_from(x->impl(),y); + node_alg::unlink(x->impl()); } - static void unlink_next(node_impl_pointer x) + typedef typename node_alg::unlink_undo unlink_undo; + + void unlink(node_type* x,unlink_undo& undo) { - node_impl_type::unlink_next(x); + node_alg::unlink(x->impl(),undo); } void calculate_max_load() @@ -1147,7 +1296,7 @@ class hashed_index: if(max_load>fml)max_load=static_cast(fml); } - void reserve(size_type n) + void reserve_for_insert(size_type n) { if(n>max_load){ size_type bc =(std::numeric_limits::max)(); @@ -1157,102 +1306,196 @@ class hashed_index: } } - void unchecked_rehash(size_type n) + void unchecked_rehash(size_type n){unchecked_rehash(n,Category());} + + void unchecked_rehash(size_type n,hashed_unique_tag) { - bucket_array_type buckets1(get_allocator(),header()->impl(),n); - auto_space hashes(get_allocator(),size()); + node_impl_type cpy_end_node; + node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node), + end_=header()->impl(); + bucket_array_type buckets_cpy(get_allocator(),cpy_end,n); + + if(size()!=0){ + auto_space< + std::size_t,allocator_type> hashes(get_allocator(),size()); + auto_space< + node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size()); + std::size_t i=0,size_=size(); + bool within_bucket=false; + BOOST_TRY{ + for(;i!=size_;++i){ + node_impl_pointer x=end_->prior(); + + /* only this can possibly throw */ + std::size_t h=hash_(key(node_type::from_impl(x)->value())); - std::size_t i=0; - node_impl_pointer x=buckets.begin(); - node_impl_pointer x_end=buckets.end(); - for(;x!=x_end;++x){ - node_impl_pointer y=x->next(); - while(y!=x){ - hashes.data()[i++]=hash_(key(node_type::from_impl(y)->value())); - y=y->next(); + hashes.data()[i]=h; + node_ptrs.data()[i]=x; + within_bucket=!node_alg::unlink_last(end_); + node_alg::link(x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end); + } + } + BOOST_CATCH(...){ + if(i!=0){ + std::size_t prev_buc=buckets.position(hashes.data()[i-1]); + if(!within_bucket)prev_buc=~prev_buc; + + for(std::size_t j=i;j--;){ + std::size_t buc=buckets.position(hashes.data()[j]); + node_impl_pointer x=node_ptrs.data()[j]; + if(buc==prev_buc)node_alg::append(x,end_); + else node_alg::link(x,buckets.at(buc),end_); + prev_buc=buc; + } + } + BOOST_RETHROW; } + BOOST_CATCH_END } - i=0; - x=buckets.begin(); - for(;x!=x_end;++x){ - node_impl_pointer y=x->next(); - while(y!=x){ - node_impl_pointer z=y->next(); - std::size_t buc1=buckets1.position(hashes.data()[i++]); - node_impl_pointer x1=buckets1.at(buc1); - link(y,x1); - y=z; + end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_; + end_->next()=cpy_end->next(); + end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_; + buckets.swap(buckets_cpy); + calculate_max_load(); + } + + void unchecked_rehash(size_type n,hashed_non_unique_tag) + { + node_impl_type cpy_end_node; + node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node), + end_=header()->impl(); + bucket_array_type buckets_cpy(get_allocator(),cpy_end,n); + + if(size()!=0){ + auto_space< + std::size_t,allocator_type> hashes(get_allocator(),size()); + auto_space< + node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size()); + std::size_t i=0; + bool within_bucket=false; + BOOST_TRY{ + for(;;++i){ + node_impl_pointer x=end_->prior(); + if(x==end_)break; + + /* only this can possibly throw */ + std::size_t h=hash_(key(node_type::from_impl(x)->value())); + + hashes.data()[i]=h; + node_ptrs.data()[i]=x; + std::pair p= + node_alg::unlink_last_group(end_); + node_alg::link_range( + p.first,x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end); + within_bucket=!(p.second); + } + } + BOOST_CATCH(...){ + if(i!=0){ + std::size_t prev_buc=buckets.position(hashes.data()[i-1]); + if(!within_bucket)prev_buc=~prev_buc; + + for(std::size_t j=i;j--;){ + std::size_t buc=buckets.position(hashes.data()[j]); + node_impl_pointer x=node_ptrs.data()[j], + y= + x->prior()->next()!=node_impl_type::base_pointer_from(x)&& + x->prior()->next()->prior()!=x? + node_impl_type::pointer_from(x->prior()->next()):x; + node_alg::unlink_range(y,x); + if(buc==prev_buc)node_alg::append_range(y,x,end_); + else node_alg::link_range(y,x,buckets.at(buc),end_); + prev_buc=buc; + } + } + BOOST_RETHROW; } + BOOST_CATCH_END } - buckets.swap(buckets1); + end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_; + end_->next()=cpy_end->next(); + end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_; + buckets.swap(buckets_cpy); calculate_max_load(); - first_bucket=buckets.first_nonempty(0); + } + + bool in_place(node_impl_pointer x,key_param_type k,std::size_t buc)const + { + return in_place(x,k,buc,Category()); } bool in_place( node_impl_pointer x,key_param_type k,std::size_t buc, hashed_unique_tag)const { - std::less_equal leq; - node_impl_pointer bbegin=buckets.begin(); - node_impl_pointer bend=buckets.end(); - node_impl_pointer pbuc=x->next(); - - while(!leq(bbegin,pbuc)||!leq(pbuc,bend))pbuc=pbuc->next(); - if(buc!=static_cast(pbuc-bbegin))return false; - - node_impl_pointer y=x; - while(y->next()!=x){ - y=y->next(); - if(y==pbuc)continue; - if(eq_(k,key(node_type::from_impl(y)->value())))return false; + bool found=false; + for(node_impl_pointer y=buckets.at(buc)->prior(); + y!=node_impl_pointer(0);y=node_alg::after_local(y)){ + if(y==x)found=true; + else if(eq_(k,key(node_type::from_impl(y)->value())))return false; } - return true; + return found; } bool in_place( node_impl_pointer x,key_param_type k,std::size_t buc, hashed_non_unique_tag)const { - std::less_equal leq; - node_impl_pointer bbegin=buckets.begin(); - node_impl_pointer bend=buckets.end(); - node_impl_pointer pbuc=x->next(); - - while(!leq(bbegin,pbuc)||!leq(pbuc,bend))pbuc=pbuc->next(); - if(buc!=static_cast(pbuc-bbegin))return false; - - node_impl_pointer y=x->next(); - if(y!=pbuc){ - if(eq_(k,key(node_type::from_impl(y)->value()))){ - /* adjacent to equivalent element -> in place */ - return true; - } - else{ - y=y->next(); - while(y!=pbuc){ - if(eq_(k,key(node_type::from_impl(y)->value())))return false; - y=y->next(); + bool found=false; + int range_size=0; + for(node_impl_pointer y=buckets.at(buc)->prior();y!=node_impl_pointer(0);){ + if(node_alg::is_first_of_group(y)){ /* group of 3 or more */ + if(y==x){ + /* in place <-> equal to some other member of the group */ + return eq_( + k, + key(node_type::from_impl( + node_impl_type::pointer_from(y->next()))->value())); + } + else{ + node_impl_pointer z= + node_alg::after_local(y->next()->prior()); /* end of range */ + if(eq_(k,key(node_type::from_impl(y)->value()))){ + if(found)return false; /* x lies outside */ + do{ + if(y==x)return true; + y=node_alg::after_local(y); + }while(y!=z); + return false; /* x not found */ + } + else{ + if(range_size==1&&!found)return false; + if(range_size==2)return found; + range_size=0; + y=z; /* skip range (and potentially x, too, which is fine) */ + } } } - } - while(y->next()!=x){ - y=y->next(); - if(eq_(k,key(node_type::from_impl(y)->value()))){ - while(y->next()!=x){ - y=y->next(); - if(!eq_(k,key(node_type::from_impl(y)->value())))return false; + else{ /* group of 1 or 2 */ + if(y==x){ + if(range_size==1)return true; + range_size=1; + found=true; } - /* after a group of equivalent elements --> in place */ - return true; + else if(eq_(k,key(node_type::from_impl(y)->value()))){ + if(range_size==0&&found)return false; + if(range_size==1&&!found)return false; + if(range_size==2)return false; + ++range_size; + } + else{ + if(range_size==1&&!found)return false; + if(range_size==2)return found; + range_size=0; + } + y=node_alg::after_local(y); } } - return true; + return found; } - #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) void detach_iterators(node_type* x) { @@ -1290,7 +1533,6 @@ class hashed_index: bucket_array_type buckets; float mlf; size_type max_load; - std::size_t first_bucket; #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ BOOST_WORKAROUND(__MWERKS__,<=0x3003) @@ -1298,6 +1540,30 @@ class hashed_index: #endif }; +/* comparison */ + +template< + typename KeyFromValue,typename Hash,typename Pred, + typename SuperMeta,typename TagList,typename Category +> +bool operator==( + const hashed_index& x, + const hashed_index& y) +{ + return x.equals(y); +} + +template< + typename KeyFromValue,typename Hash,typename Pred, + typename SuperMeta,typename TagList,typename Category +> +bool operator!=( + const hashed_index& x, + const hashed_index& y) +{ + return !(x==y); +} + /* specialized algorithms */ template< @@ -1328,7 +1594,7 @@ struct hashed_unique template struct node_class { - typedef detail::hashed_index_node type; + typedef detail::hashed_index_node type; }; template @@ -1353,7 +1619,8 @@ struct hashed_non_unique template struct node_class { - typedef detail::hashed_index_node type; + typedef detail::hashed_index_node< + Super,detail::hashed_non_unique_tag> type; }; template diff --git a/src/thirdparty/boost_lib/boost/multi_index/hashed_index_fwd.hpp b/src/thirdparty/boost_lib/boost/multi_index/hashed_index_fwd.hpp index cd8c2272a..d77e36c32 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/hashed_index_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/hashed_index_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP #define BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -27,6 +27,22 @@ template< > class hashed_index; +template< + typename KeyFromValue,typename Hash,typename Pred, + typename SuperMeta,typename TagList,typename Category +> +bool operator==( + const hashed_index& x, + const hashed_index& y); + +template< + typename KeyFromValue,typename Hash,typename Pred, + typename SuperMeta,typename TagList,typename Category +> +bool operator!=( + const hashed_index& x, + const hashed_index& y); + template< typename KeyFromValue,typename Hash,typename Pred, typename SuperMeta,typename TagList,typename Category diff --git a/src/thirdparty/boost_lib/boost/multi_index/identity.hpp b/src/thirdparty/boost_lib/boost/multi_index/identity.hpp index b402ad70d..1dbaf3b22 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/identity.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/identity.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_IDENTITY_HPP #define BOOST_MULTI_INDEX_IDENTITY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -42,16 +42,6 @@ namespace detail{ * arbitrary combinations of these (vg. Type** or auto_ptr.) */ -/* NB. Some overloads of operator() have an extra dummy parameter int=0. - * This disambiguator serves several purposes: - * - Without it, MSVC++ 6.0 incorrectly regards some overloads as - * specializations of a previous member function template. - * - MSVC++ 6.0/7.0 seem to incorrectly treat some different memfuns - * as if they have the same signature. - * - If remove_const is broken due to lack of PTS, int=0 avoids the - * declaration of memfuns with identical signature. - */ - template struct const_identity_base { @@ -81,7 +71,7 @@ struct const_identity_base } Type& operator()( - const reference_wrapper::type>& x,int=0)const + const reference_wrapper::type>& x)const { return x.get(); } @@ -108,7 +98,7 @@ struct non_const_identity_base return operator()(*x); } - const Type& operator()(const Type& x,int=0)const + const Type& operator()(const Type& x)const { return x; } @@ -118,7 +108,7 @@ struct non_const_identity_base return x; } - const Type& operator()(const reference_wrapper& x,int=0)const + const Type& operator()(const reference_wrapper& x)const { return x.get(); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/identity_fwd.hpp b/src/thirdparty/boost_lib/boost/multi_index/identity_fwd.hpp index baafa43a5..af6bd55ef 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/identity_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/identity_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_IDENTITY_FWD_HPP #define BOOST_MULTI_INDEX_IDENTITY_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/indexed_by.hpp b/src/thirdparty/boost_lib/boost/multi_index/indexed_by.hpp index 94a8dcb7c..d2217e391 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/indexed_by.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/indexed_by.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_INDEXED_BY_HPP #define BOOST_MULTI_INDEX_INDEXED_BY_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -31,12 +31,8 @@ */ #if !defined(BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE) -#if defined(BOOST_MSVC)&&(BOOST_MSVC<1300) -#define BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE 5 -#else #define BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE #endif -#endif #if BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/mem_fun.hpp b/src/thirdparty/boost_lib/boost/multi_index/mem_fun.hpp index bb18c1097..71fc21702 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/mem_fun.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/mem_fun.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_MEM_FUN_HPP #define BOOST_MULTI_INDEX_MEM_FUN_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -112,6 +112,9 @@ struct mem_fun * news:microsoft.public.vc.language, 21st nov 2002, * http://groups.google.com/groups? * hl=en&lr=&ie=UTF-8&selm=ukwvg3O0BHA.1512%40tkmsftngp05 + * + * MSVC++ 6.0 support has been dropped and [const_]mem_fun_explicit is + * deprecated. */ template< @@ -183,28 +186,18 @@ struct mem_fun_explicit } }; -/* BOOST_MULTI_INDEX_CONST_MEM_FUN and BOOST_MULTI_INDEX_MEM_FUN resolve to - * [const_]mem_fun_explicit for MSVC++ 6.0 and to [const_]mem_fun otherwise. +/* BOOST_MULTI_INDEX_CONST_MEM_FUN and BOOST_MULTI_INDEX_MEM_FUN used to + * resolve to [const_]mem_fun_explicit for MSVC++ 6.0 and to + * [const_]mem_fun otherwise. Support for this compiler having been dropped, + * they are now just wrappers over [const_]mem_fun kept for backwards- + * compatibility reasons. */ -#if defined(BOOST_MSVC)&&(BOOST_MSVC<1300) - -#define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \ -::boost::multi_index::const_mem_fun_explicit<\ - Class,Type,Type (Class::*)()const,&Class::MemberFunName > -#define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \ -::boost::multi_index::mem_fun_explicit<\ - Class,Type,Type (Class::*)(),&Class::MemberFunName > - -#else - #define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \ ::boost::multi_index::const_mem_fun< Class,Type,&Class::MemberFunName > #define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \ ::boost::multi_index::mem_fun< Class,Type,&Class::MemberFunName > -#endif - } /* namespace multi_index */ } /* namespace boost */ diff --git a/src/thirdparty/boost_lib/boost/multi_index/member.hpp b/src/thirdparty/boost_lib/boost/multi_index/member.hpp index 848e9b23b..192cf1be8 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/member.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/member.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_MEMBER_HPP #define BOOST_MULTI_INDEX_MEMBER_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -41,16 +41,6 @@ namespace detail{ * arbitrary combinations of these (vg. T** or auto_ptr.) */ -/* NB. Some overloads of operator() have an extra dummy parameter int=0. - * This disambiguator serves several purposes: - * - Without it, MSVC++ 6.0 incorrectly regards some overloads as - * specializations of a previous member function template. - * - MSVC++ 6.0/7.0 seem to incorrectly treat some different memfuns - * as if they have the same signature. - * - If remove_const is broken due to lack of PTS, int=0 avoids the - * declaration of memfuns with identical signature. - */ - template struct const_member_base { @@ -80,7 +70,7 @@ struct const_member_base return operator()(x.get()); } - Type& operator()(const reference_wrapper& x,int=0)const + Type& operator()(const reference_wrapper& x)const { return operator()(x.get()); } @@ -105,7 +95,7 @@ struct non_const_member_base return operator()(*x); } - const Type& operator()(const Class& x,int=0)const + const Type& operator()(const Class& x)const { return x.*PtrToMember; } @@ -115,7 +105,7 @@ struct non_const_member_base return x.*PtrToMember; } - const Type& operator()(const reference_wrapper& x,int=0)const + const Type& operator()(const reference_wrapper& x)const { return operator()(x.get()); } @@ -152,6 +142,9 @@ namespace detail{ * Surprisingly enough, other compilers, like Intel C++ 7.0/7.1 and * Visual Age 6.0, have similar bugs. This replacement of member<> * can be used for them too. + * + * Support for such old compilers is dropped and + * [non_]const_member_offset_base is deprecated. */ template @@ -186,7 +179,7 @@ struct const_member_offset_base return operator()(x.get()); } - Type& operator()(const reference_wrapper& x,int=0)const + Type& operator()(const reference_wrapper& x)const { return operator()(x.get()); } @@ -211,7 +204,7 @@ struct non_const_member_offset_base return operator()(*x); } - const Type& operator()(const Class& x,int=0)const + const Type& operator()(const Class& x)const { return *static_cast( static_cast( @@ -226,7 +219,7 @@ struct non_const_member_offset_base static_cast(static_cast(&x))+OffsetOfMember)); } - const Type& operator()(const reference_wrapper& x,int=0)const + const Type& operator()(const reference_wrapper& x)const { return operator()(x.get()); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/ordered_index.hpp b/src/thirdparty/boost_lib/boost/multi_index/ordered_index.hpp index 3dedbc140..3f0ae5d84 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/ordered_index.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/ordered_index.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2013 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -36,7 +36,7 @@ #ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_HPP #define BOOST_MULTI_INDEX_ORDERED_INDEX_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -58,7 +58,6 @@ #include #include #include -#include #include #include #include @@ -117,16 +116,9 @@ class ordered_index: BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - ,public safe_ctr_proxy_impl< - bidir_node_iterator< - ordered_index_node >, - ordered_index > -#else ,public safe_mode::safe_container< ordered_index > #endif -#endif { #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ @@ -164,16 +156,9 @@ class ordered_index: typedef typename allocator_type::const_reference const_reference; #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_mode::safe_iterator< - bidir_node_iterator, - safe_ctr_proxy< - bidir_node_iterator > > iterator; -#else typedef safe_mode::safe_iterator< bidir_node_iterator, ordered_index> iterator; -#endif #else typedef bidir_node_iterator iterator; #endif @@ -213,13 +198,7 @@ class ordered_index: private: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_ctr_proxy_impl< - bidir_node_iterator, - ordered_index> safe_super; -#else typedef safe_mode::safe_container safe_super; -#endif #endif typedef typename call_traits< @@ -256,25 +235,37 @@ class ordered_index: } #endif - allocator_type get_allocator()const + allocator_type get_allocator()const BOOST_NOEXCEPT { return this->final().get_allocator(); } /* iterators */ - iterator begin(){return make_iterator(leftmost());} - const_iterator begin()const{return make_iterator(leftmost());} - iterator end(){return make_iterator(header());} - const_iterator end()const{return make_iterator(header());} - reverse_iterator rbegin(){return make_reverse_iterator(end());} - const_reverse_iterator rbegin()const{return make_reverse_iterator(end());} - reverse_iterator rend(){return make_reverse_iterator(begin());} - const_reverse_iterator rend()const{return make_reverse_iterator(begin());} - const_iterator cbegin()const{return begin();} - const_iterator cend()const{return end();} - const_reverse_iterator crbegin()const{return rbegin();} - const_reverse_iterator crend()const{return rend();} + iterator + begin()BOOST_NOEXCEPT{return make_iterator(leftmost());} + const_iterator + begin()const BOOST_NOEXCEPT{return make_iterator(leftmost());} + iterator + end()BOOST_NOEXCEPT{return make_iterator(header());} + const_iterator + end()const BOOST_NOEXCEPT{return make_iterator(header());} + reverse_iterator + rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());} + const_reverse_iterator + rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());} + reverse_iterator + rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());} + const_reverse_iterator + rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());} + const_iterator + cbegin()const BOOST_NOEXCEPT{return begin();} + const_iterator + cend()const BOOST_NOEXCEPT{return end();} + const_reverse_iterator + crbegin()const BOOST_NOEXCEPT{return rbegin();} + const_reverse_iterator + crend()const BOOST_NOEXCEPT{return rend();} iterator iterator_to(const value_type& x) { @@ -288,9 +279,9 @@ class ordered_index: /* capacity */ - bool empty()const{return this->final_empty_();} - size_type size()const{return this->final_size_();} - size_type max_size()const{return this->final_max_size_();} + bool empty()const BOOST_NOEXCEPT{return this->final_empty_();} + size_type size()const BOOST_NOEXCEPT{return this->final_size_();} + size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();} /* modifiers */ @@ -431,7 +422,7 @@ class ordered_index: } template - bool modify(iterator position,Modifier mod,Rollback back) + bool modify(iterator position,Modifier mod,Rollback back_) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); @@ -448,7 +439,7 @@ class ordered_index: #endif return this->final_modify_( - mod,back,static_cast(position.get_node())); + mod,back_,static_cast(position.get_node())); } template @@ -463,7 +454,7 @@ class ordered_index: } template - bool modify_key(iterator position,Modifier mod,Rollback back) + bool modify_key(iterator position,Modifier mod,Rollback back_) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); @@ -472,7 +463,7 @@ class ordered_index: return modify( position, modify_key_adaptor(mod,key), - modify_key_adaptor(back,key)); + modify_key_adaptor(back_,key)); } void swap(ordered_index& x) @@ -482,7 +473,7 @@ class ordered_index: this->final_swap_(x.final()); } - void clear() + void clear()BOOST_NOEXCEPT { BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT; this->final_clear_(); @@ -709,32 +700,35 @@ class ordered_index: } template - node_type* insert_(value_param_type v,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,final_node_type*& x,Variant variant) { link_info inf; if(!link_point(key(v),inf,Category())){ - return node_type::from_impl(inf.pos); + return static_cast(node_type::from_impl(inf.pos)); } - node_type* res=static_cast(super::insert_(v,x,variant)); + final_node_type* res=super::insert_(v,x,variant); if(res==x){ - node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl()); + node_impl_type::link( + static_cast(x)->impl(),inf.side,inf.pos,header()->impl()); } return res; } template - node_type* insert_( - value_param_type v,node_type* position,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,node_type* position,final_node_type*& x,Variant variant) { link_info inf; if(!hinted_link_point(key(v),position,inf,Category())){ - return node_type::from_impl(inf.pos); + return static_cast(node_type::from_impl(inf.pos)); } - node_type* res=static_cast(super::insert_(v,position,x,variant)); + final_node_type* res=super::insert_(v,position,x,variant); if(res==x){ - node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl()); + node_impl_type::link( + static_cast(x)->impl(),inf.side,inf.pos,header()->impl()); } return res; } @@ -1324,7 +1318,8 @@ class ordered_index: ordered_non_unique_tag) { lm.load( - ::boost::bind(&ordered_index::rearranger,this,_1,_2), + ::boost::bind( + &ordered_index::rearranger,this,::boost::arg<1>(),::boost::arg<2>()), ar,version); super::load_(ar,version,lm); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/ordered_index_fwd.hpp b/src/thirdparty/boost_lib/boost/multi_index/ordered_index_fwd.hpp index 6288a712d..dbd040fa3 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/ordered_index_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/ordered_index_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP #define BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/random_access_index.hpp b/src/thirdparty/boost_lib/boost/multi_index/random_access_index.hpp index 246018729..7702776fb 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/random_access_index.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/random_access_index.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2013 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP #define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -32,7 +32,6 @@ #include #include #include -#include #include #include #include @@ -81,16 +80,9 @@ class random_access_index: BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - ,public safe_ctr_proxy_impl< - rnd_node_iterator< - random_access_index_node >, - random_access_index > -#else ,public safe_mode::safe_container< random_access_index > #endif -#endif { #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ @@ -125,16 +117,9 @@ class random_access_index: typedef typename allocator_type::const_reference const_reference; #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_mode::safe_iterator< - rnd_node_iterator, - safe_ctr_proxy< - rnd_node_iterator > > iterator; -#else typedef safe_mode::safe_iterator< rnd_node_iterator, random_access_index> iterator; -#endif #else typedef rnd_node_iterator iterator; #endif @@ -174,14 +159,8 @@ class random_access_index: private: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_ctr_proxy_impl< - rnd_node_iterator, - random_access_index> safe_super; -#else typedef safe_mode::safe_container< random_access_index> safe_super; -#endif #endif typedef typename call_traits< @@ -236,27 +215,37 @@ class random_access_index: for(size_type i=0;ifinal().get_allocator(); } /* iterators */ - iterator begin() + iterator begin()BOOST_NOEXCEPT {return make_iterator(node_type::from_impl(*ptrs.begin()));} - const_iterator begin()const + const_iterator begin()const BOOST_NOEXCEPT {return make_iterator(node_type::from_impl(*ptrs.begin()));} - iterator end(){return make_iterator(header());} - const_iterator end()const{return make_iterator(header());} - reverse_iterator rbegin(){return make_reverse_iterator(end());} - const_reverse_iterator rbegin()const{return make_reverse_iterator(end());} - reverse_iterator rend(){return make_reverse_iterator(begin());} - const_reverse_iterator rend()const{return make_reverse_iterator(begin());} - const_iterator cbegin()const{return begin();} - const_iterator cend()const{return end();} - const_reverse_iterator crbegin()const{return rbegin();} - const_reverse_iterator crend()const{return rend();} + iterator + end()BOOST_NOEXCEPT{return make_iterator(header());} + const_iterator + end()const BOOST_NOEXCEPT{return make_iterator(header());} + reverse_iterator + rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());} + const_reverse_iterator + rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());} + reverse_iterator + rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());} + const_reverse_iterator + rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());} + const_iterator + cbegin()const BOOST_NOEXCEPT{return begin();} + const_iterator + cend()const BOOST_NOEXCEPT{return end();} + const_reverse_iterator + crbegin()const BOOST_NOEXCEPT{return rbegin();} + const_reverse_iterator + crend()const BOOST_NOEXCEPT{return rend();} iterator iterator_to(const value_type& x) { @@ -270,10 +259,10 @@ class random_access_index: /* capacity */ - bool empty()const{return this->final_empty_();} - size_type size()const{return this->final_size_();} - size_type max_size()const{return this->final_max_size_();} - size_type capacity()const{return ptrs.capacity();} + bool empty()const BOOST_NOEXCEPT{return this->final_empty_();} + size_type size()const BOOST_NOEXCEPT{return this->final_size_();} + size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();} + size_type capacity()const BOOST_NOEXCEPT{return ptrs.capacity();} void reserve(size_type n) { @@ -467,7 +456,7 @@ class random_access_index: } template - bool modify(iterator position,Modifier mod,Rollback back) + bool modify(iterator position,Modifier mod,Rollback back_) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); @@ -484,7 +473,7 @@ class random_access_index: #endif return this->final_modify_( - mod,back,static_cast(position.get_node())); + mod,back_,static_cast(position.get_node())); } void swap(random_access_index& x) @@ -494,7 +483,7 @@ class random_access_index: this->final_swap_(x.final()); } - void clear() + void clear()BOOST_NOEXCEPT { BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT; this->final_clear_(); @@ -665,7 +654,7 @@ class random_access_index: get_allocator(),ptrs,comp); } - void reverse() + void reverse()BOOST_NOEXCEPT { BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT; node_impl_type::reverse(ptrs.begin(),ptrs.end()); @@ -781,22 +770,22 @@ class random_access_index: } template - node_type* insert_(value_param_type v,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,final_node_type*& x,Variant variant) { ptrs.room_for_one(); - node_type* res=static_cast(super::insert_(v,x,variant)); - if(res==x)ptrs.push_back(x->impl()); + final_node_type* res=super::insert_(v,x,variant); + if(res==x)ptrs.push_back(static_cast(x)->impl()); return res; } template - node_type* insert_( - value_param_type v,node_type* position,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,node_type* position,final_node_type*& x,Variant variant) { ptrs.room_for_one(); - node_type* res= - static_cast(super::insert_(v,position,x,variant)); - if(res==x)ptrs.push_back(x->impl()); + final_node_type* res=super::insert_(v,position,x,variant); + if(res==x)ptrs.push_back(static_cast(x)->impl()); return res; } @@ -906,7 +895,10 @@ class random_access_index: typedef random_access_index_loader loader; loader ld(get_allocator(),ptrs); - lm.load(::boost::bind(&loader::rearrange,&ld,_1,_2),ar,version); + lm.load( + ::boost::bind( + &loader::rearrange,&ld,::boost::arg<1>(),::boost::arg<2>()), + ar,version); } /* exit scope so that ld frees its resources */ super::load_(ar,version,lm); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/random_access_index_fwd.hpp b/src/thirdparty/boost_lib/boost/multi_index/random_access_index_fwd.hpp index cf8f2ca03..2ea192954 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/random_access_index_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/random_access_index_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP #define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/safe_mode_errors.hpp b/src/thirdparty/boost_lib/boost/multi_index/safe_mode_errors.hpp index ff6f96065..1904706ed 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/safe_mode_errors.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/safe_mode_errors.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP #define BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/sequenced_index.hpp b/src/thirdparty/boost_lib/boost/multi_index/sequenced_index.hpp index 7ea3c45e3..d56edddd1 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/sequenced_index.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/sequenced_index.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2013 Joaquin M Lopez Munoz. +/* Copyright 2003-2014 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP #define BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -29,7 +29,6 @@ #include #include #include -#include #include #include #include @@ -75,16 +74,9 @@ class sequenced_index: BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - ,public safe_ctr_proxy_impl< - bidir_node_iterator< - sequenced_index_node >, - sequenced_index > -#else ,public safe_mode::safe_container< sequenced_index > #endif -#endif { #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ @@ -116,16 +108,9 @@ class sequenced_index: typedef typename allocator_type::const_reference const_reference; #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_mode::safe_iterator< - bidir_node_iterator, - safe_ctr_proxy< - bidir_node_iterator > > iterator; -#else typedef safe_mode::safe_iterator< bidir_node_iterator, sequenced_index> iterator; -#endif #else typedef bidir_node_iterator iterator; #endif @@ -165,14 +150,8 @@ class sequenced_index: private: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - typedef safe_ctr_proxy_impl< - bidir_node_iterator, - sequenced_index> safe_super; -#else typedef safe_mode::safe_container< sequenced_index> safe_super; -#endif #endif typedef typename call_traits::param_type value_param_type; @@ -226,27 +205,37 @@ class sequenced_index: for(size_type i=0;ifinal().get_allocator(); } /* iterators */ - iterator begin() + iterator begin()BOOST_NOEXCEPT {return make_iterator(node_type::from_impl(header()->next()));} - const_iterator begin()const + const_iterator begin()const BOOST_NOEXCEPT {return make_iterator(node_type::from_impl(header()->next()));} - iterator end(){return make_iterator(header());} - const_iterator end()const{return make_iterator(header());} - reverse_iterator rbegin(){return make_reverse_iterator(end());} - const_reverse_iterator rbegin()const{return make_reverse_iterator(end());} - reverse_iterator rend(){return make_reverse_iterator(begin());} - const_reverse_iterator rend()const{return make_reverse_iterator(begin());} - const_iterator cbegin()const{return begin();} - const_iterator cend()const{return end();} - const_reverse_iterator crbegin()const{return rbegin();} - const_reverse_iterator crend()const{return rend();} + iterator + end()BOOST_NOEXCEPT{return make_iterator(header());} + const_iterator + end()const BOOST_NOEXCEPT{return make_iterator(header());} + reverse_iterator + rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());} + const_reverse_iterator + rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());} + reverse_iterator + rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());} + const_reverse_iterator + rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());} + const_iterator + cbegin()const BOOST_NOEXCEPT{return begin();} + const_iterator + cend()const BOOST_NOEXCEPT{return end();} + const_reverse_iterator + crbegin()const BOOST_NOEXCEPT{return rbegin();} + const_reverse_iterator + crend()const BOOST_NOEXCEPT{return rend();} iterator iterator_to(const value_type& x) { @@ -260,9 +249,9 @@ class sequenced_index: /* capacity */ - bool empty()const{return this->final_empty_();} - size_type size()const{return this->final_size_();} - size_type max_size()const{return this->final_max_size_();} + bool empty()const BOOST_NOEXCEPT{return this->final_empty_();} + size_type size()const BOOST_NOEXCEPT{return this->final_size_();} + size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();} void resize(size_type n) { @@ -422,7 +411,7 @@ class sequenced_index: } template - bool modify(iterator position,Modifier mod,Rollback back) + bool modify(iterator position,Modifier mod,Rollback back_) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); @@ -439,7 +428,7 @@ class sequenced_index: #endif return this->final_modify_( - mod,back,static_cast(position.get_node())); + mod,back_,static_cast(position.get_node())); } void swap(sequenced_index& x) @@ -449,7 +438,7 @@ class sequenced_index: this->final_swap_(x.final()); } - void clear() + void clear()BOOST_NOEXCEPT { BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT; this->final_clear_(); @@ -571,7 +560,7 @@ class sequenced_index: sequenced_index_sort(header(),comp); } - void reverse() + void reverse()BOOST_NOEXCEPT { BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT; node_impl_type::reverse(header()->impl()); @@ -679,20 +668,20 @@ class sequenced_index: } template - node_type* insert_(value_param_type v,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,final_node_type*& x,Variant variant) { - node_type* res=static_cast(super::insert_(v,x,variant)); - if(res==x)link(x); + final_node_type* res=super::insert_(v,x,variant); + if(res==x)link(static_cast(x)); return res; } template - node_type* insert_( - value_param_type v,node_type* position,node_type* x,Variant variant) + final_node_type* insert_( + value_param_type v,node_type* position,final_node_type*& x,Variant variant) { - node_type* res= - static_cast(super::insert_(v,position,x,variant)); - if(res==x)link(x); + final_node_type* res=super::insert_(v,position,x,variant); + if(res==x)link(static_cast(x)); return res; } @@ -796,7 +785,8 @@ class sequenced_index: Archive& ar,const unsigned int version,const index_loader_type& lm) { lm.load( - ::boost::bind(&sequenced_index::rearranger,this,_1,_2), + ::boost::bind( + &sequenced_index::rearranger,this,::boost::arg<1>(),::boost::arg<2>()), ar,version); super::load_(ar,version,lm); } diff --git a/src/thirdparty/boost_lib/boost/multi_index/sequenced_index_fwd.hpp b/src/thirdparty/boost_lib/boost/multi_index/sequenced_index_fwd.hpp index 5211390b6..a019f2a6d 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/sequenced_index_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/sequenced_index_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP #define BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/multi_index/tag.hpp b/src/thirdparty/boost_lib/boost/multi_index/tag.hpp index ba7cab4f1..ce51f8241 100644 --- a/src/thirdparty/boost_lib/boost/multi_index/tag.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index/tag.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_TAG_HPP #define BOOST_MULTI_INDEX_TAG_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -34,12 +34,8 @@ */ #if !defined(BOOST_MULTI_INDEX_LIMIT_TAG_SIZE) -#if defined(BOOST_MSVC)&&(BOOST_MSVC<1300) -#define BOOST_MULTI_INDEX_LIMIT_TAG_SIZE 3 -#else #define BOOST_MULTI_INDEX_LIMIT_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE #endif -#endif #if BOOST_MULTI_INDEX_LIMIT_TAG_SIZE=1200) +#if defined(_MSC_VER) #pragma once #endif @@ -37,7 +37,6 @@ #include #include #include -#include #include #include #include @@ -90,13 +89,10 @@ class multi_index_container: Value,IndexSpecifierList,Allocator>::type >::type>, BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder< - typename detail::prevent_eti< + typename boost::detail::allocator::rebind_to< Allocator, - typename boost::detail::allocator::rebind_to< - Allocator, - typename detail::multi_index_node_type< - Value,IndexSpecifierList,Allocator>::type - >::type + typename detail::multi_index_node_type< + Value,IndexSpecifierList,Allocator>::type >::type::pointer, multi_index_container >, public detail::multi_index_base_type< @@ -125,52 +121,25 @@ class multi_index_container: Value,IndexSpecifierList,Allocator>::type super; typedef typename boost::detail::allocator::rebind_to< - Allocator, - typename super::node_type + Allocator, + typename super::node_type >::type node_allocator; typedef ::boost::base_from_member< node_allocator> bfm_allocator; typedef detail::header_holder< - typename detail::prevent_eti< - Allocator, - node_allocator - >::type::pointer, + typename node_allocator::pointer, multi_index_container> bfm_header; -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - /* see definition of index_type_list below */ - typedef typename super::index_type_list super_index_type_list; -#endif public: /* All types are inherited from super, a few are explicitly * brought forward here to save us some typename's. */ - typedef typename super::ctor_args_list ctor_args_list; - typedef IndexSpecifierList index_specifier_type_list; + typedef typename super::ctor_args_list ctor_args_list; + typedef IndexSpecifierList index_specifier_type_list; -#if BOOST_WORKAROUND(BOOST_MSVC,<1300) - /* MSVC++ 6.0 chokes on moderately long index lists (around 6 indices - * or more), with errors ranging from corrupt exes to duplicate - * comdats. The following type hiding hack alleviates this condition; - * best results combined with type hiding of the indexed_by construct - * itself, as explained in the "Compiler specifics" section of - * the documentation. - */ - - struct index_type_list:super_index_type_list - { - typedef index_type_list type; - typedef typename super_index_type_list::back back; - typedef mpl::v_iter begin; - typedef mpl::v_iter< - type, - mpl::size::value> end; - }; -#else typedef typename super::index_type_list index_type_list; -#endif typedef typename super::iterator_type_list iterator_type_list; typedef typename super::const_iterator_type_list const_iterator_type_list; @@ -272,7 +241,7 @@ class multi_index_container: { BOOST_MULTI_INDEX_CHECK_INVARIANT; BOOST_TRY{ - typedef typename std::initializer_list::iterator init_iterator; + typedef const Value* init_iterator; iterator hint=super::end(); for(init_iterator first=list.begin(),last=list.end(); @@ -361,7 +330,7 @@ class multi_index_container: std::initializer_list list) { BOOST_MULTI_INDEX_CHECK_INVARIANT; - typedef typename std::initializer_list::iterator init_iterator; + typedef const Value* init_iterator; multi_index_container x(*this,detail::do_not_copy_elements_tag()); iterator hint=x.end(); @@ -375,7 +344,7 @@ class multi_index_container: } #endif - allocator_type get_allocator()const + allocator_type get_allocator()const BOOST_NOEXCEPT { return allocator_type(bfm_allocator::member); } @@ -391,15 +360,14 @@ class multi_index_container: }; template - typename nth_index::type& get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) + typename nth_index::type& get()BOOST_NOEXCEPT { BOOST_STATIC_ASSERT(N>=0&&N::type::value); return *this; } template - const typename nth_index::type& get( - BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const + const typename nth_index::type& get()const BOOST_NOEXCEPT { BOOST_STATIC_ASSERT(N>=0&&N::type::value); return *this; @@ -425,14 +393,13 @@ class multi_index_container: }; template - typename index::type& get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag)) + typename index::type& get()BOOST_NOEXCEPT { return *this; } template - const typename index::type& get( - BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))const + const typename index::type& get()const BOOST_NOEXCEPT { return *this; } @@ -454,11 +421,9 @@ class multi_index_container: }; template - typename nth_index_iterator::type project( - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) + typename nth_index_iterator::type project(IteratorType it) { - typedef typename nth_index::type index; + typedef typename nth_index::type index_type; #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ BOOST_STATIC_ASSERT( @@ -469,15 +434,13 @@ class multi_index_container: BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); - return index::make_iterator(static_cast(it.get_node())); + return index_type::make_iterator(static_cast(it.get_node())); } template - typename nth_index_const_iterator::type project( - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const + typename nth_index_const_iterator::type project(IteratorType it)const { - typedef typename nth_index::type index; + typedef typename nth_index::type index_type; #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ BOOST_STATIC_ASSERT(( @@ -488,7 +451,7 @@ class multi_index_container: BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); - return index::make_iterator(static_cast(it.get_node())); + return index_type::make_iterator(static_cast(it.get_node())); } #endif @@ -508,11 +471,9 @@ class multi_index_container: }; template - typename index_iterator::type project( - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) + typename index_iterator::type project(IteratorType it) { - typedef typename index::type index; + typedef typename index::type index_type; #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ BOOST_STATIC_ASSERT( @@ -522,15 +483,13 @@ class multi_index_container: BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); - return index::make_iterator(static_cast(it.get_node())); + return index_type::make_iterator(static_cast(it.get_node())); } template - typename index_const_iterator::type project( - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const + typename index_const_iterator::type project(IteratorType it)const { - typedef typename index::type index; + typedef typename index::type index_type; #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ BOOST_STATIC_ASSERT(( @@ -541,7 +500,7 @@ class multi_index_container: BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); - return index::make_iterator(static_cast(it.get_node())); + return index_type::make_iterator(static_cast(it.get_node())); } #endif @@ -595,23 +554,15 @@ class multi_index_container: template std::pair insert_(const Value& v,Variant variant) { - node_type* x=allocate_node(); - BOOST_TRY{ - node_type* res=super::insert_(v,x,variant); - if(res==x){ - ++node_count; - return std::pair(res,true); - } - else{ - deallocate_node(x); - return std::pair(res,false); - } + node_type* x=0; + node_type* res=super::insert_(v,x,variant); + if(res==x){ + ++node_count; + return std::pair(res,true); } - BOOST_CATCH(...){ - deallocate_node(x); - BOOST_RETHROW; + else{ + return std::pair(res,false); } - BOOST_CATCH_END } std::pair insert_(const Value& v) @@ -702,23 +653,15 @@ class multi_index_container: std::pair insert_( const Value& v,node_type* position,Variant variant) { - node_type* x=allocate_node(); - BOOST_TRY{ - node_type* res=super::insert_(v,position,x,variant); - if(res==x){ - ++node_count; - return std::pair(res,true); - } - else{ - deallocate_node(x); - return std::pair(res,false); - } + node_type* x=0; + node_type* res=super::insert_(v,position,x,variant); + if(res==x){ + ++node_count; + return std::pair(res,true); } - BOOST_CATCH(...){ - deallocate_node(x); - BOOST_RETHROW; + else{ + return std::pair(res,false); } - BOOST_CATCH_END } std::pair insert_(const Value& v,node_type* position) @@ -886,7 +829,7 @@ class multi_index_container: } template - bool modify_(Modifier& mod,Rollback& back,node_type* x) + bool modify_(Modifier& mod,Rollback& back_,node_type* x) { mod(const_cast(x->value())); @@ -896,7 +839,7 @@ class multi_index_container: } BOOST_CATCH(...){ BOOST_TRY{ - back(const_cast(x->value())); + back_(const_cast(x->value())); BOOST_RETHROW; } BOOST_CATCH(...){ @@ -909,7 +852,7 @@ class multi_index_container: BOOST_TRY{ if(!b){ - back(const_cast(x->value())); + back_(const_cast(x->value())); return false; } else return true; @@ -934,17 +877,10 @@ class multi_index_container: template void save(Archive& ar,const unsigned int version)const { - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) const serialization::collection_size_type s(size_()); const detail::serialization_version value_version; ar< value_version; if(version<1){ @@ -982,11 +916,6 @@ class multi_index_container: else{ ar>>serialization::make_nvp("value_version",value_version); } -#else - std::size_t s; - unsigned int value_version=0; - ar>>serialization::make_nvp("count",s); -#endif index_loader_type lm(bfm_allocator::member,s); @@ -1050,8 +979,7 @@ template typename nth_index< multi_index_container,N>::type& get( - multi_index_container& m - BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) + multi_index_container& m)BOOST_NOEXCEPT { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; @@ -1059,7 +987,7 @@ get( multi_index_container< Value,IndexSpecifierList,Allocator>, N - >::type index; + >::type index_type; BOOST_STATIC_ASSERT(N>=0&& N< @@ -1067,7 +995,7 @@ get( BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list >::type::value); - return detail::converter::index(m); + return detail::converter::index(m); } template @@ -1075,7 +1003,7 @@ const typename nth_index< multi_index_container,N>::type& get( const multi_index_container& m - BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) +)BOOST_NOEXCEPT { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; @@ -1083,7 +1011,7 @@ get( multi_index_container< Value,IndexSpecifierList,Allocator>, N - >::type index; + >::type index_type; BOOST_STATIC_ASSERT(N>=0&& N< @@ -1091,7 +1019,7 @@ get( BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list >::type::value); - return detail::converter::index(m); + return detail::converter::index(m); } /* retrieval of indices by tag */ @@ -1119,8 +1047,7 @@ template< typename ::boost::multi_index::index< multi_index_container,Tag>::type& get( - multi_index_container& m - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) + multi_index_container& m)BOOST_NOEXCEPT { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; @@ -1128,9 +1055,9 @@ get( multi_index_container< Value,IndexSpecifierList,Allocator>, Tag - >::type index; + >::type index_type; - return detail::converter::index(m); + return detail::converter::index(m); } template< @@ -1140,7 +1067,7 @@ const typename ::boost::multi_index::index< multi_index_container,Tag>::type& get( const multi_index_container& m - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) +)BOOST_NOEXCEPT { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; @@ -1148,9 +1075,9 @@ get( multi_index_container< Value,IndexSpecifierList,Allocator>, Tag - >::type index; + >::type index_type; - return detail::converter::index(m); + return detail::converter::index(m); } /* projection of iterators by number */ @@ -1158,18 +1085,13 @@ get( template struct nth_index_iterator { - typedef typename detail::prevent_eti< - nth_index, - typename nth_index::type>::type::iterator type; + typedef typename nth_index::type::iterator type; }; template struct nth_index_const_iterator { - typedef typename detail::prevent_eti< - nth_index, - typename nth_index::type - >::type::const_iterator type; + typedef typename nth_index::type::const_iterator type; }; template< @@ -1179,15 +1101,13 @@ typename nth_index_iterator< multi_index_container,N>::type project( multi_index_container& m, - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) + IteratorType it) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; - typedef typename nth_index::type index; + typedef typename nth_index::type index_type; -#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ - (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ +#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, @@ -1203,7 +1123,7 @@ project( BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif - return detail::converter::iterator( + return detail::converter::iterator( m,static_cast(it.get_node())); } @@ -1214,15 +1134,13 @@ typename nth_index_const_iterator< multi_index_container,N>::type project( const multi_index_container& m, - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) + IteratorType it) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; - typedef typename nth_index::type index; + typedef typename nth_index::type index_type; -#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ - (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ +#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, @@ -1241,7 +1159,7 @@ project( BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif - return detail::converter::const_iterator( + return detail::converter::const_iterator( m,static_cast(it.get_node())); } @@ -1268,16 +1186,14 @@ typename index_iterator< multi_index_container,Tag>::type project( multi_index_container& m, - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) + IteratorType it) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename ::boost::multi_index::index< - multi_index_type,Tag>::type index; + multi_index_type,Tag>::type index_type; -#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ - (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ +#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, @@ -1293,7 +1209,7 @@ project( BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif - return detail::converter::iterator( + return detail::converter::iterator( m,static_cast(it.get_node())); } @@ -1304,16 +1220,14 @@ typename index_const_iterator< multi_index_container,Tag>::type project( const multi_index_container& m, - IteratorType it - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) + IteratorType it) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename ::boost::multi_index::index< - multi_index_type,Tag>::type index; + multi_index_type,Tag>::type index_type; -#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ - (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ +#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, @@ -1332,7 +1246,7 @@ project( BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif - return detail::converter::const_iterator( + return detail::converter::const_iterator( m,static_cast(it.get_node())); } @@ -1416,8 +1330,7 @@ void swap( } /* namespace multi_index */ -#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)&&\ - !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) /* class version = 1 : we now serialize the size through * boost::serialization::collection_size_type. * class version = 2 : proper use of {save|load}_construct_data. diff --git a/src/thirdparty/boost_lib/boost/multi_index_container_fwd.hpp b/src/thirdparty/boost_lib/boost/multi_index_container_fwd.hpp index 99e8db36c..b35acad40 100644 --- a/src/thirdparty/boost_lib/boost/multi_index_container_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/multi_index_container_fwd.hpp @@ -1,4 +1,4 @@ -/* Copyright 2003-2008 Joaquin M Lopez Munoz. +/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) @@ -9,7 +9,7 @@ #ifndef BOOST_MULTI_INDEX_FWD_HPP #define BOOST_MULTI_INDEX_FWD_HPP -#if defined(_MSC_VER)&&(_MSC_VER>=1200) +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/noncopyable.hpp b/src/thirdparty/boost_lib/boost/noncopyable.hpp index eb8e2e70d..e998ee864 100644 --- a/src/thirdparty/boost_lib/boost/noncopyable.hpp +++ b/src/thirdparty/boost_lib/boost/noncopyable.hpp @@ -1,48 +1,17 @@ -// Boost noncopyable.hpp header file --------------------------------------// +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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 Beman Dawes 1999-2003. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_NONCOPYABLE_HPP +#define BOOST_NONCOPYABLE_HPP -// See http://www.boost.org/libs/utility for documentation. +// The header file at this path is deprecated; +// use boost/core/noncopyable.hpp instead. -#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED -#define BOOST_NONCOPYABLE_HPP_INCLUDED +#include -#include - -namespace boost { - -// Private copy constructor and copy assignment ensure classes derived from -// class noncopyable cannot be copied. - -// Contributed by Dave Abrahams - -namespace noncopyable_ // protection from unintended ADL -{ - class noncopyable - { - protected: -#ifndef BOOST_NO_DEFAULTED_FUNCTIONS - BOOST_CONSTEXPR noncopyable() = default; - ~noncopyable() = default; -#else - noncopyable() {} - ~noncopyable() {} #endif -#ifndef BOOST_NO_DELETED_FUNCTIONS - noncopyable( const noncopyable& ) = delete; - noncopyable& operator=( const noncopyable& ) = delete; -#else - private: // emphasize the following members are private - noncopyable( const noncopyable& ); - noncopyable& operator=( const noncopyable& ); -#endif - }; -} - -typedef noncopyable_::noncopyable noncopyable; - -} // namespace boost - -#endif // BOOST_NONCOPYABLE_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/nondet_random.hpp b/src/thirdparty/boost_lib/boost/nondet_random.hpp index 0002e800b..1ec2e446d 100644 --- a/src/thirdparty/boost_lib/boost/nondet_random.hpp +++ b/src/thirdparty/boost_lib/boost/nondet_random.hpp @@ -5,7 +5,7 @@ * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * - * $Id: nondet_random.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $ + * $Id$ * * Revision history * 2000-02-18 Portability fixes (thanks to Beman Dawes) diff --git a/src/thirdparty/boost_lib/boost/operators.hpp b/src/thirdparty/boost_lib/boost/operators.hpp index b524cee38..82c374ebb 100644 --- a/src/thirdparty/boost_lib/boost/operators.hpp +++ b/src/thirdparty/boost_lib/boost/operators.hpp @@ -97,14 +97,7 @@ namespace boost { namespace detail { -template class empty_base { - -// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0 -#if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0 - bool dummy; -#endif - -}; +template class empty_base {}; } // namespace detail } // namespace boost @@ -711,7 +704,6 @@ struct random_access_iteratable // the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as // necessary. // -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // is_chained_base<> - a traits class used to distinguish whether an operator // template argument is being used for base class chaining, or is specifying a @@ -809,24 +801,6 @@ BOOST_OPERATOR_TEMPLATE2(template_name##2) \ BOOST_OPERATOR_TEMPLATE1(template_name##1) -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -# define BOOST_OPERATOR_TEMPLATE4(template_name4) \ - BOOST_IMPORT_TEMPLATE4(template_name4) -# define BOOST_OPERATOR_TEMPLATE3(template_name3) \ - BOOST_IMPORT_TEMPLATE3(template_name3) -# define BOOST_OPERATOR_TEMPLATE2(template_name2) \ - BOOST_IMPORT_TEMPLATE2(template_name2) -# define BOOST_OPERATOR_TEMPLATE1(template_name1) \ - BOOST_IMPORT_TEMPLATE1(template_name1) - - // In this case we can only assume that template_name<> is equivalent to the - // more commonly needed template_name1<> form. -# define BOOST_OPERATOR_TEMPLATE(template_name) \ - template > \ - struct template_name : template_name##1 {}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { @@ -897,14 +871,10 @@ struct operators2 , bitwise2 > > {}; -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct operators : operators2 {}; template struct operators -#else -template struct operators -#endif : totally_ordered instead (the workaround did not +// actually compile when BOOST_NO_LIMITS was defined in +// any case, so we loose nothing). (John Maddock) +// 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never +// worked with stock GCC; trying to get it to do that broke +// vc-stlport. +// 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp. +// Removed unused BOOST_EXPLICIT_TARGET macro. Moved +// boost::detail::type to boost/type.hpp. Made it compile with +// stock gcc again (Dave Abrahams) +// 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal +// Review (Beman Dawes) +// 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams) +// 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC +// (Dave Abrahams) +// 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams) +// 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes) +// 27 Jun 00 More MSVC6 workarounds +// 15 Jun 00 Add workarounds for MSVC6 +// 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov) +// 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar) +// 29 Dec 99 Change using declarations so usages in other namespaces work +// correctly (Dave Abrahams) +// 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors +// as suggested Darin Adler and improved by Valentin Bonnard. +// 2 Sep 99 Remove controversial asserts, simplify, rename. +// 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast, +// place in nested namespace. +// 3 Aug 99 Initial version + +#ifndef BOOST_POLYMORPHIC_CAST_HPP +#define BOOST_POLYMORPHIC_CAST_HPP + +# include +# include +# include + +namespace boost +{ +// See the documentation for descriptions of how to choose between +// static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<> + +// polymorphic_cast --------------------------------------------------------// + + // Runtime checked polymorphic downcasts and crosscasts. + // Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup, + // section 15.8 exercise 1, page 425. + + template + inline Target polymorphic_cast(Source* x) + { + Target tmp = dynamic_cast(x); + if ( tmp == 0 ) throw std::bad_cast(); + return tmp; + } + +// polymorphic_downcast ----------------------------------------------------// + + // BOOST_ASSERT() checked polymorphic downcast. Crosscasts prohibited. + + // WARNING: Because this cast uses BOOST_ASSERT(), it violates + // the One Definition Rule if used in multiple translation units + // where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER + // NDEBUG are defined inconsistently. + + // Contributed by Dave Abrahams + + template + inline Target polymorphic_downcast(Source* x) + { + BOOST_ASSERT( dynamic_cast(x) == x ); // detect logic error + return static_cast(x); + } + +} // namespace boost + +#endif // BOOST_POLYMORPHIC_CAST_HPP diff --git a/src/thirdparty/boost_lib/boost/predef.h b/src/thirdparty/boost_lib/boost/predef.h new file mode 100644 index 000000000..753cd61e8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef.h @@ -0,0 +1,19 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_H +#define BOOST_PREDEF_H + +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture.h b/src/thirdparty/boost_lib/boost/predef/architecture.h new file mode 100644 index 000000000..b32701ece --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture.h @@ -0,0 +1,30 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_H +#define BOOST_PREDEF_ARCHITECTURE_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +/*#include */ + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/alpha.h b/src/thirdparty/boost_lib/boost/predef/architecture/alpha.h new file mode 100644 index 000000000..6365ec45e --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/alpha.h @@ -0,0 +1,60 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_ALPHA_H +#define BOOST_PREDEF_ARCHITECTURE_ALPHA_H + +#include +#include + +/*` +[heading `BOOST_ARCH_ALPHA`] + +[@http://en.wikipedia.org/wiki/DEC_Alpha DEC Alpha] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + [[`__alpha__`] [__predef_detection__]] + [[`__alpha`] [__predef_detection__]] + [[`_M_ALPHA`] [__predef_detection__]] + + [[`__alpha_ev4__`] [4.0.0]] + [[`__alpha_ev5__`] [5.0.0]] + [[`__alpha_ev6__`] [6.0.0]] + ] + */ + +#define BOOST_ARCH_ALPHA BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__alpha__) || defined(__alpha) || \ + defined(_M_ALPHA) +# undef BOOST_ARCH_ALPHA +# if !defined(BOOST_ARCH_ALPHA) && defined(__alpha_ev4__) +# define BOOST_ARCH_ALPHA BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_ARCH_ALPHA) && defined(__alpha_ev5__) +# define BOOST_ARCH_ALPHA BOOST_VERSION_NUMBER(5,0,0) +# endif +# if !defined(BOOST_ARCH_ALPHA) && defined(__alpha_ev6__) +# define BOOST_ARCH_ALPHA BOOST_VERSION_NUMBER(6,0,0) +# endif +# if !defined(BOOST_ARCH_ALPHA) +# define BOOST_ARCH_ALPHA BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_ALPHA +# define BOOST_ARCH_ALPHA_AVAILABLE +#endif + +#define BOOST_ARCH_ALPHA_NAME "DEC Alpha" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_ALPHA,BOOST_ARCH_ALPHA_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/arm.h b/src/thirdparty/boost_lib/boost/predef/architecture/arm.h new file mode 100644 index 000000000..4974895b2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/arm.h @@ -0,0 +1,71 @@ +/* +Copyright Rene Rivera 2008-2013 +Copyright Franz Detro 2014 +Copyright (c) Microsoft Corporation 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_ARM_H +#define BOOST_PREDEF_ARCHITECTURE_ARM_H + +#include +#include + +/*` +[heading `BOOST_ARCH_ARM`] + +[@http://en.wikipedia.org/wiki/ARM_architecture ARM] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__arm__`] [__predef_detection__]] + [[`__arm64`] [__predef_detection__]] + [[`__thumb__`] [__predef_detection__]] + [[`__TARGET_ARCH_ARM`] [__predef_detection__]] + [[`__TARGET_ARCH_THUMB`] [__predef_detection__]] + [[`_M_ARM`] [__predef_detection__]] + + [[`__arm64`] [8.0.0]] + [[`__TARGET_ARCH_ARM`] [V.0.0]] + [[`__TARGET_ARCH_THUMB`] [V.0.0]] + [[`_M_ARM`] [V.0.0]] + ] + */ + +#define BOOST_ARCH_ARM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__arm__) || defined(__arm64) || defined(__thumb__) || \ + defined(__TARGET_ARCH_ARM) || defined(__TARGET_ARCH_THUMB) || \ + defined(_M_ARM) +# undef BOOST_ARCH_ARM +# if !defined(BOOST_ARCH_ARM) && defined(__arm64) +# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(8,0,0) +# endif +# if !defined(BOOST_ARCH_ARM) && defined(__TARGET_ARCH_ARM) +# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__TARGET_ARCH_ARM,0,0) +# endif +# if !defined(BOOST_ARCH_ARM) && defined(__TARGET_ARCH_THUMB) +# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__TARGET_ARCH_THUMB,0,0) +# endif +# if !defined(BOOST_ARCH_ARM) && defined(_M_ARM) +# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(_M_ARM,0,0) +# endif +# if !defined(BOOST_ARCH_ARM) +# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_ARM +# define BOOST_ARCH_ARM_AVAILABLE +#endif + +#define BOOST_ARCH_ARM_NAME "ARM" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_ARM,BOOST_ARCH_ARM_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/blackfin.h b/src/thirdparty/boost_lib/boost/predef/architecture/blackfin.h new file mode 100644 index 000000000..ae3407e93 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/blackfin.h @@ -0,0 +1,47 @@ +/* +Copyright Rene Rivera 2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_BLACKFIN_H +#define BOOST_PREDEF_ARCHITECTURE_BLACKFIN_H + +#include +#include + +/*` +[heading `BOOST_ARCH_BLACKFIN`] + +Blackfin Processors from Analog Devices. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__bfin__`] [__predef_detection__]] + [[`__BFIN__`] [__predef_detection__]] + [[`bfin`] [__predef_detection__]] + [[`BFIN`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_BLACKFIN BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__bfin__) || defined(__BFIN__) || \ + defined(bfin) || defined(BFIN) +# undef BOOST_ARCH_BLACKFIN +# define BOOST_ARCH_BLACKFIN BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_BLACKFIN +# define BOOST_ARCH_BLACKFIN_AVAILABLE +#endif + +#define BOOST_ARCH_BLACKFIN_NAME "Blackfin" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_BLACKFIN,BOOST_ARCH_BLACKFIN_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/convex.h b/src/thirdparty/boost_lib/boost/predef/architecture/convex.h new file mode 100644 index 000000000..3b425a04c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/convex.h @@ -0,0 +1,67 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_CONVEX_H +#define BOOST_PREDEF_ARCHITECTURE_CONVEX_H + +#include +#include + +/*` +[heading `BOOST_ARCH_CONVEX`] + +[@http://en.wikipedia.org/wiki/Convex_Computer Convex Computer] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__convex__`] [__predef_detection__]] + + [[`__convex_c1__`] [1.0.0]] + [[`__convex_c2__`] [2.0.0]] + [[`__convex_c32__`] [3.2.0]] + [[`__convex_c34__`] [3.4.0]] + [[`__convex_c38__`] [3.8.0]] + ] + */ + +#define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__convex__) +# undef BOOST_ARCH_CONVEX +# if !defined(BOOST_ARCH_CONVEX) && defined(__convex_c1__) +# define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER(1,0,0) +# endif +# if !defined(BOOST_ARCH_CONVEX) && defined(__convex_c2__) +# define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER(2,0,0) +# endif +# if !defined(BOOST_ARCH_CONVEX) && defined(__convex_c32__) +# define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER(3,2,0) +# endif +# if !defined(BOOST_ARCH_CONVEX) && defined(__convex_c34__) +# define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER(3,4,0) +# endif +# if !defined(BOOST_ARCH_CONVEX) && defined(__convex_c38__) +# define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER(3,8,0) +# endif +# if !defined(BOOST_ARCH_CONVEX) +# define BOOST_ARCH_CONVEX BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_CONVEX +# define BOOST_ARCH_CONVEX_AVAILABLE +#endif + +#define BOOST_ARCH_CONVEX_NAME "Convex Computer" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_CONVEX,BOOST_ARCH_CONVEX_NAME) + + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/ia64.h b/src/thirdparty/boost_lib/boost/predef/architecture/ia64.h new file mode 100644 index 000000000..4b5a10331 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/ia64.h @@ -0,0 +1,49 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_IA64_H +#define BOOST_PREDEF_ARCHITECTURE_IA64_H + +#include +#include + +/*` +[heading `BOOST_ARCH_IA64`] + +[@http://en.wikipedia.org/wiki/Ia64 Intel Itanium 64] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__ia64__`] [__predef_detection__]] + [[`_IA64`] [__predef_detection__]] + [[`__IA64__`] [__predef_detection__]] + [[`__ia64`] [__predef_detection__]] + [[`_M_IA64`] [__predef_detection__]] + [[`__itanium__`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_IA64 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__ia64__) || defined(_IA64) || \ + defined(__IA64__) || defined(__ia64) || \ + defined(_M_IA64) || defined(__itanium__) +# undef BOOST_ARCH_IA64 +# define BOOST_ARCH_IA64 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_IA64 +# define BOOST_ARCH_IA64_AVAILABLE +#endif + +#define BOOST_ARCH_IA64_NAME "Intel Itanium 64" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_IA64,BOOST_ARCH_IA64_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/m68k.h b/src/thirdparty/boost_lib/boost/predef/architecture/m68k.h new file mode 100644 index 000000000..09c3cd3a0 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/m68k.h @@ -0,0 +1,83 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_M68K_H +#define BOOST_PREDEF_ARCHITECTURE_M68K_H + +#include +#include + +/*` +[heading `BOOST_ARCH_M68K`] + +[@http://en.wikipedia.org/wiki/M68k Motorola 68k] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__m68k__`] [__predef_detection__]] + [[`M68000`] [__predef_detection__]] + + [[`__mc68060__`] [6.0.0]] + [[`mc68060`] [6.0.0]] + [[`__mc68060`] [6.0.0]] + [[`__mc68040__`] [4.0.0]] + [[`mc68040`] [4.0.0]] + [[`__mc68040`] [4.0.0]] + [[`__mc68030__`] [3.0.0]] + [[`mc68030`] [3.0.0]] + [[`__mc68030`] [3.0.0]] + [[`__mc68020__`] [2.0.0]] + [[`mc68020`] [2.0.0]] + [[`__mc68020`] [2.0.0]] + [[`__mc68010__`] [1.0.0]] + [[`mc68010`] [1.0.0]] + [[`__mc68010`] [1.0.0]] + [[`__mc68000__`] [0.0.1]] + [[`mc68000`] [0.0.1]] + [[`__mc68000`] [0.0.1]] + ] + */ + +#define BOOST_ARCH_M68K BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__m68k__) || defined(M68000) +# undef BOOST_ARCH_M68K +# if !defined(BOOST_ARCH_M68K) && (defined(__mc68060__) || defined(mc68060) || defined(__mc68060)) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER(6,0,0) +# endif +# if !defined(BOOST_ARCH_M68K) && (defined(__mc68040__) || defined(mc68040) || defined(__mc68040)) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_ARCH_M68K) && (defined(__mc68030__) || defined(mc68030) || defined(__mc68030)) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER(3,0,0) +# endif +# if !defined(BOOST_ARCH_M68K) && (defined(__mc68020__) || defined(mc68020) || defined(__mc68020)) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER(2,0,0) +# endif +# if !defined(BOOST_ARCH_M68K) && (defined(__mc68010__) || defined(mc68010) || defined(__mc68010)) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER(1,0,0) +# endif +# if !defined(BOOST_ARCH_M68K) && (defined(__mc68000__) || defined(mc68000) || defined(__mc68000)) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER_AVAILABLE +# endif +# if !defined(BOOST_ARCH_M68K) +# define BOOST_ARCH_M68K BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_M68K +# define BOOST_ARCH_M68K_AVAILABLE +#endif + +#define BOOST_ARCH_M68K_NAME "Motorola 68k" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_M68K,BOOST_ARCH_M68K_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/mips.h b/src/thirdparty/boost_lib/boost/predef/architecture/mips.h new file mode 100644 index 000000000..ae88428c2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/mips.h @@ -0,0 +1,74 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_MIPS_H +#define BOOST_PREDEF_ARCHITECTURE_MIPS_H + +#include +#include + +/*` +[heading `BOOST_ARCH_MIPS`] + +[@http://en.wikipedia.org/wiki/MIPS_architecture MIPS] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__mips__`] [__predef_detection__]] + [[`__mips`] [__predef_detection__]] + [[`__MIPS__`] [__predef_detection__]] + + [[`__mips`] [V.0.0]] + [[`_MIPS_ISA_MIPS1`] [1.0.0]] + [[`_R3000`] [1.0.0]] + [[`_MIPS_ISA_MIPS2`] [2.0.0]] + [[`__MIPS_ISA2__`] [2.0.0]] + [[`_R4000`] [2.0.0]] + [[`_MIPS_ISA_MIPS3`] [3.0.0]] + [[`__MIPS_ISA3__`] [3.0.0]] + [[`_MIPS_ISA_MIPS4`] [4.0.0]] + [[`__MIPS_ISA4__`] [4.0.0]] + ] + */ + +#define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__mips__) || defined(__mips) || \ + defined(__MIPS__) +# undef BOOST_ARCH_MIPS +# if !defined(BOOST_ARCH_MIPS) && (defined(__mips)) +# define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER(__mips,0,0) +# endif +# if !defined(BOOST_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS1) || defined(_R3000)) +# define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER(1,0,0) +# endif +# if !defined(BOOST_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS2) || defined(__MIPS_ISA2__) || defined(_R4000)) +# define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER(2,0,0) +# endif +# if !defined(BOOST_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS3) || defined(__MIPS_ISA3__)) +# define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER(3,0,0) +# endif +# if !defined(BOOST_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS4) || defined(__MIPS_ISA4__)) +# define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_ARCH_MIPS) +# define BOOST_ARCH_MIPS BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_MIPS +# define BOOST_ARCH_MIPS_AVAILABLE +#endif + +#define BOOST_ARCH_MIPS_NAME "MIPS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_MIPS,BOOST_ARCH_MIPS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/parisc.h b/src/thirdparty/boost_lib/boost/predef/architecture/parisc.h new file mode 100644 index 000000000..e843dd210 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/parisc.h @@ -0,0 +1,65 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_PARISC_H +#define BOOST_PREDEF_ARCHITECTURE_PARISC_H + +#include +#include + +/*` +[heading `BOOST_ARCH_PARISK`] + +[@http://en.wikipedia.org/wiki/PA-RISC_family HP/PA RISC] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__hppa__`] [__predef_detection__]] + [[`__hppa`] [__predef_detection__]] + [[`__HPPA__`] [__predef_detection__]] + + [[`_PA_RISC1_0`] [1.0.0]] + [[`_PA_RISC1_1`] [1.1.0]] + [[`__HPPA11__`] [1.1.0]] + [[`__PA7100__`] [1.1.0]] + [[`_PA_RISC2_0`] [2.0.0]] + [[`__RISC2_0__`] [2.0.0]] + [[`__HPPA20__`] [2.0.0]] + [[`__PA8000__`] [2.0.0]] + ] + */ + +#define BOOST_ARCH_PARISC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__hppa__) || defined(__hppa) || defined(__HPPA__) +# undef BOOST_ARCH_PARISC +# if !defined(BOOST_ARCH_PARISC) && (defined(_PA_RISC1_0)) +# define BOOST_ARCH_PARISC BOOST_VERSION_NUMBER(1,0,0) +# endif +# if !defined(BOOST_ARCH_PARISC) && (defined(_PA_RISC1_1) || defined(__HPPA11__) || defined(__PA7100__)) +# define BOOST_ARCH_PARISC BOOST_VERSION_NUMBER(1,1,0) +# endif +# if !defined(BOOST_ARCH_PARISC) && (defined(_PA_RISC2_0) || defined(__RISC2_0__) || defined(__HPPA20__) || defined(__PA8000__)) +# define BOOST_ARCH_PARISC BOOST_VERSION_NUMBER(2,0,0) +# endif +# if !defined(BOOST_ARCH_PARISC) +# define BOOST_ARCH_PARISC BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_PARISC +# define BOOST_ARCH_PARISC_AVAILABLE +#endif + +#define BOOST_ARCH_PARISC_NAME "HP/PA RISC" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_PARISC,BOOST_ARCH_PARISC_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/ppc.h b/src/thirdparty/boost_lib/boost/predef/architecture/ppc.h new file mode 100644 index 000000000..cc743e74f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/ppc.h @@ -0,0 +1,73 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_PPC_H +#define BOOST_PREDEF_ARCHITECTURE_PPC_H + +#include +#include + +/*` +[heading `BOOST_ARCH_PPC`] + +[@http://en.wikipedia.org/wiki/PowerPC PowerPC] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__powerpc`] [__predef_detection__]] + [[`__powerpc__`] [__predef_detection__]] + [[`__POWERPC__`] [__predef_detection__]] + [[`__ppc__`] [__predef_detection__]] + [[`_M_PPC`] [__predef_detection__]] + [[`_ARCH_PPC`] [__predef_detection__]] + [[`__PPCGECKO__`] [__predef_detection__]] + [[`__PPCBROADWAY__`] [__predef_detection__]] + [[`_XENON`] [__predef_detection__]] + + [[`__ppc601__`] [6.1.0]] + [[`_ARCH_601`] [6.1.0]] + [[`__ppc603__`] [6.3.0]] + [[`_ARCH_603`] [6.3.0]] + [[`__ppc604__`] [6.4.0]] + [[`__ppc604__`] [6.4.0]] + ] + */ + +#define BOOST_ARCH_PPC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__powerpc) || defined(__powerpc__) || \ + defined(__POWERPC__) || defined(__ppc__) || \ + defined(_M_PPC) || defined(_ARCH_PPC) || \ + defined(__PPCGECKO__) || defined(__PPCBROADWAY__) || \ + defined(_XENON) +# undef BOOST_ARCH_PPC +# if !defined (BOOST_ARCH_PPC) && (defined(__ppc601__) || defined(_ARCH_601)) +# define BOOST_ARCH_PPC BOOST_VERSION_NUMBER(6,1,0) +# endif +# if !defined (BOOST_ARCH_PPC) && (defined(__ppc603__) || defined(_ARCH_603)) +# define BOOST_ARCH_PPC BOOST_VERSION_NUMBER(6,3,0) +# endif +# if !defined (BOOST_ARCH_PPC) && (defined(__ppc604__) || defined(__ppc604__)) +# define BOOST_ARCH_PPC BOOST_VERSION_NUMBER(6,4,0) +# endif +# if !defined (BOOST_ARCH_PPC) +# define BOOST_ARCH_PPC BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_PPC +# define BOOST_ARCH_PPC_AVAILABLE +#endif + +#define BOOST_ARCH_PPC_NAME "PowerPC" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_PPC,BOOST_ARCH_PPC_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/pyramid.h b/src/thirdparty/boost_lib/boost/predef/architecture/pyramid.h new file mode 100644 index 000000000..26d5293e6 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/pyramid.h @@ -0,0 +1,43 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_PYRAMID_H +#define BOOST_PREDEF_ARCHITECTURE_PYRAMID_H + +#include +#include + +/*` +[heading `BOOST_ARCH_PYRAMID`] + +Pyramid 9810 architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`pyr`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_PYRAMID BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(pyr) +# undef BOOST_ARCH_PYRAMID +# define BOOST_ARCH_PYRAMID BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_PYRAMID +# define BOOST_ARCH_PYRAMID_AVAILABLE +#endif + +#define BOOST_ARCH_PYRAMID_NAME "Pyramid 9810" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_PYRAMID,BOOST_ARCH_PYRAMID_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/rs6k.h b/src/thirdparty/boost_lib/boost/predef/architecture/rs6k.h new file mode 100644 index 000000000..20dd64bac --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/rs6k.h @@ -0,0 +1,56 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_RS6K_H +#define BOOST_PREDEF_ARCHITECTURE_RS6K_H + +#include +#include + +/*` +[heading `BOOST_ARCH_RS6000`] + +[@http://en.wikipedia.org/wiki/RS/6000 RS/6000] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__THW_RS6000`] [__predef_detection__]] + [[`_IBMR2`] [__predef_detection__]] + [[`_POWER`] [__predef_detection__]] + [[`_ARCH_PWR`] [__predef_detection__]] + [[`_ARCH_PWR2`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_RS6000 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__THW_RS6000) || defined(_IBMR2) || \ + defined(_POWER) || defined(_ARCH_PWR) || \ + defined(_ARCH_PWR2) +# undef BOOST_ARCH_RS6000 +# define BOOST_ARCH_RS6000 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_RS6000 +# define BOOST_ARCH_RS6000_AVAILABLE +#endif + +#define BOOST_ARCH_RS6000_NAME "RS/6000" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_RS6000,BOOST_ARCH_RS6000_NAME) + +#define BOOST_ARCH_PWR BOOST_ARCH_RS6000 + +#if BOOST_ARCH_PWR +# define BOOST_ARCH_PWR_AVAILABLE +#endif + +#define BOOST_ARCH_PWR_NAME BOOST_ARCH_RS6000_NAME + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/sparc.h b/src/thirdparty/boost_lib/boost/predef/architecture/sparc.h new file mode 100644 index 000000000..9c91cdaca --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/sparc.h @@ -0,0 +1,55 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_SPARC_H +#define BOOST_PREDEF_ARCHITECTURE_SPARC_H + +#include +#include + +/*` +[heading `BOOST_ARCH_SPARC`] + +[@http://en.wikipedia.org/wiki/SPARC SPARC] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__sparc__`] [__predef_detection__]] + [[`__sparc`] [__predef_detection__]] + + [[`__sparcv9`] [9.0.0]] + [[`__sparcv8`] [8.0.0]] + ] + */ + +#define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__sparc__) || defined(__sparc) +# undef BOOST_ARCH_SPARC +# if !defined(BOOST_ARCH_SPARC) && defined(__sparcv9) +# define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER(9,0,0) +# endif +# if !defined(BOOST_ARCH_SPARC) && defined(__sparcv8) +# define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER(8,0,0) +# endif +# if !defined(BOOST_ARCH_SPARC) +# define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_SPARC +# define BOOST_ARCH_SPARC_AVAILABLE +#endif + +#define BOOST_ARCH_SPARC_NAME "SPARC" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_SPARC,BOOST_ARCH_SPARC_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/superh.h b/src/thirdparty/boost_lib/boost/predef/architecture/superh.h new file mode 100644 index 000000000..ef88242d1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/superh.h @@ -0,0 +1,68 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_SUPERH_H +#define BOOST_PREDEF_ARCHITECTURE_SUPERH_H + +#include +#include + +/*` +[heading `BOOST_ARCH_SH`] + +[@http://en.wikipedia.org/wiki/SuperH SuperH] architecture: +If available versions \[1-5\] are specifically detected. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__sh__`] [__predef_detection__]] + + [[`__SH5__`] [5.0.0]] + [[`__SH4__`] [4.0.0]] + [[`__sh3__`] [3.0.0]] + [[`__SH3__`] [3.0.0]] + [[`__sh2__`] [2.0.0]] + [[`__sh1__`] [1.0.0]] + ] + */ + +#define BOOST_ARCH_SH BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__sh__) +# undef BOOST_ARCH_SH +# if !defined(BOOST_ARCH_SH) && (defined(__SH5__)) +# define BOOST_ARCH_SH BOOST_VERSION_NUMBER(5,0,0) +# endif +# if !defined(BOOST_ARCH_SH) && (defined(__SH4__)) +# define BOOST_ARCH_SH BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_ARCH_SH) && (defined(__sh3__) || defined(__SH3__)) +# define BOOST_ARCH_SH BOOST_VERSION_NUMBER(3,0,0) +# endif +# if !defined(BOOST_ARCH_SH) && (defined(__sh2__)) +# define BOOST_ARCH_SH BOOST_VERSION_NUMBER(2,0,0) +# endif +# if !defined(BOOST_ARCH_SH) && (defined(__sh1__)) +# define BOOST_ARCH_SH BOOST_VERSION_NUMBER(1,0,0) +# endif +# if !defined(BOOST_ARCH_SH) +# define BOOST_ARCH_SH BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_SH +# define BOOST_ARCH_SH_AVAILABLE +#endif + +#define BOOST_ARCH_SH_NAME "SuperH" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_SH,BOOST_ARCH_SH_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/sys370.h b/src/thirdparty/boost_lib/boost/predef/architecture/sys370.h new file mode 100644 index 000000000..507ee8637 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/sys370.h @@ -0,0 +1,44 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_SYS370_H +#define BOOST_PREDEF_ARCHITECTURE_SYS370_H + +#include +#include + +/*` +[heading `BOOST_ARCH_SYS370`] + +[@http://en.wikipedia.org/wiki/System/370 System/370] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__370__`] [__predef_detection__]] + [[`__THW_370__`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_SYS370 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__370__) || defined(__THW_370__) +# undef BOOST_ARCH_SYS370 +# define BOOST_ARCH_SYS370 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_SYS370 +# define BOOST_ARCH_SYS370_AVAILABLE +#endif + +#define BOOST_ARCH_SYS370_NAME "System/370" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_SYS370,BOOST_ARCH_SYS370_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/sys390.h b/src/thirdparty/boost_lib/boost/predef/architecture/sys390.h new file mode 100644 index 000000000..070117a70 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/sys390.h @@ -0,0 +1,44 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_SYS390_H +#define BOOST_PREDEF_ARCHITECTURE_SYS390_H + +#include +#include + +/*` +[heading `BOOST_ARCH_SYS390`] + +[@http://en.wikipedia.org/wiki/System/390 System/390] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__s390__`] [__predef_detection__]] + [[`__s390x__`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_SYS390 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__s390__) || defined(__s390x__) +# undef BOOST_ARCH_SYS390 +# define BOOST_ARCH_SYS390 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_SYS390 +# define BOOST_ARCH_SYS390_AVAILABLE +#endif + +#define BOOST_ARCH_SYS390_NAME "System/390" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_SYS390,BOOST_ARCH_SYS390_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/x86.h b/src/thirdparty/boost_lib/boost/predef/architecture/x86.h new file mode 100644 index 000000000..fa9a025c4 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/x86.h @@ -0,0 +1,38 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_X86_H +#define BOOST_PREDEF_ARCHITECTURE_X86_H + +#include +#include + +/*` +[heading `BOOST_ARCH_X86`] + +[@http://en.wikipedia.org/wiki/X86 Intel x86] architecture. This is +a category to indicate that either `BOOST_ARCH_X86_32` or +`BOOST_ARCH_X86_64` is detected. + */ + +#define BOOST_ARCH_X86 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_ARCH_X86_32 || BOOST_ARCH_X86_64 +# undef BOOST_ARCH_X86 +# define BOOST_ARCH_X86 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_X86 +# define BOOST_ARCH_X86_AVAILABLE +#endif + +#define BOOST_ARCH_X86_NAME "Intel x86" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_X86,BOOST_ARCH_X86_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/x86/32.h b/src/thirdparty/boost_lib/boost/predef/architecture/x86/32.h new file mode 100644 index 000000000..b796f841c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/x86/32.h @@ -0,0 +1,87 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_X86_32_H +#define BOOST_PREDEF_ARCHITECTURE_X86_32_H + +#include +#include + +/*` +[heading `BOOST_ARCH_X86_32`] + +[@http://en.wikipedia.org/wiki/X86 Intel x86] architecture: +If available versions \[3-6\] are specifically detected. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`i386`] [__predef_detection__]] + [[`__i386__`] [__predef_detection__]] + [[`__i486__`] [__predef_detection__]] + [[`__i586__`] [__predef_detection__]] + [[`__i686__`] [__predef_detection__]] + [[`__i386`] [__predef_detection__]] + [[`_M_IX86`] [__predef_detection__]] + [[`_X86_`] [__predef_detection__]] + [[`__THW_INTEL__`] [__predef_detection__]] + [[`__I86__`] [__predef_detection__]] + [[`__INTEL__`] [__predef_detection__]] + + [[`__I86__`] [V.0.0]] + [[`_M_IX86`] [V.0.0]] + [[`__i686__`] [6.0.0]] + [[`__i586__`] [5.0.0]] + [[`__i486__`] [4.0.0]] + [[`__i386__`] [3.0.0]] + ] + */ + +#define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(i386) || defined(__i386__) || \ + defined(__i486__) || defined(__i586__) || \ + defined(__i686__) || defined(__i386) || \ + defined(_M_IX86) || defined(_X86_) || \ + defined(__THW_INTEL__) || defined(__I86__) || \ + defined(__INTEL__) +# undef BOOST_ARCH_X86_32 +# if !defined(BOOST_ARCH_X86_32) && defined(__I86__) +# define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER(__I86__,0,0) +# endif +# if !defined(BOOST_ARCH_X86_32) && defined(_M_IX86) +# define BOOST_ARCH_X86_32 BOOST_PREDEF_MAKE_10_VV00(_M_IX86) +# endif +# if !defined(BOOST_ARCH_X86_32) && defined(__i686__) +# define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER(6,0,0) +# endif +# if !defined(BOOST_ARCH_X86_32) && defined(__i586__) +# define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER(5,0,0) +# endif +# if !defined(BOOST_ARCH_X86_32) && defined(__i486__) +# define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_ARCH_X86_32) && defined(__i386__) +# define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER(3,0,0) +# endif +# if !defined(BOOST_ARCH_X86_32) +# define BOOST_ARCH_X86_32 BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_ARCH_X86_32 +# define BOOST_ARCH_X86_32_AVAILABLE +#endif + +#define BOOST_ARCH_X86_32_NAME "Intel x86-32" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_X86_32,BOOST_ARCH_X86_32_NAME) + +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/x86/64.h b/src/thirdparty/boost_lib/boost/predef/architecture/x86/64.h new file mode 100644 index 000000000..a035c88b1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/x86/64.h @@ -0,0 +1,50 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_X86_64_H +#define BOOST_PREDEF_ARCHITECTURE_X86_64_H + +#include +#include + +/*` +[heading `BOOST_ARCH_X86_64`] + +[@http://en.wikipedia.org/wiki/Ia64 Intel IA-64] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__x86_64`] [__predef_detection__]] + [[`__x86_64__`] [__predef_detection__]] + [[`__amd64__`] [__predef_detection__]] + [[`__amd64`] [__predef_detection__]] + [[`_M_X64`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_X86_64 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__x86_64) || defined(__x86_64__) || \ + defined(__amd64__) || defined(__amd64) || \ + defined(_M_X64) +# undef BOOST_ARCH_X86_64 +# define BOOST_ARCH_X86_64 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_X86_64 +# define BOOST_ARCH_X86_64_AVAILABLE +#endif + +#define BOOST_ARCH_X86_64_NAME "Intel x86-64" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_X86_64,BOOST_ARCH_X86_64_NAME) + +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/architecture/z.h b/src/thirdparty/boost_lib/boost/predef/architecture/z.h new file mode 100644 index 000000000..768f34277 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/architecture/z.h @@ -0,0 +1,43 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ARCHITECTURE_Z_H +#define BOOST_PREDEF_ARCHITECTURE_Z_H + +#include +#include + +/*` +[heading `BOOST_ARCH_Z`] + +[@http://en.wikipedia.org/wiki/Z/Architecture z/Architecture] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__SYSC_ZARCH__`] [__predef_detection__]] + ] + */ + +#define BOOST_ARCH_Z BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__SYSC_ZARCH__) +# undef BOOST_ARCH_Z +# define BOOST_ARCH_Z BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_ARCH_Z +# define BOOST_ARCH_Z_AVAILABLE +#endif + +#define BOOST_ARCH_Z_NAME "z/Architecture" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_Z,BOOST_ARCH_Z_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler.h b/src/thirdparty/boost_lib/boost/predef/compiler.h new file mode 100644 index 000000000..12c4dfcb8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler.h @@ -0,0 +1,41 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_H +#define BOOST_PREDEF_COMPILER_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/borland.h b/src/thirdparty/boost_lib/boost/predef/compiler/borland.h new file mode 100644 index 000000000..01b5de7c6 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/borland.h @@ -0,0 +1,64 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_BORLAND_H +#define BOOST_PREDEF_COMPILER_BORLAND_H + +#include +#include + +/*` +[heading `BOOST_COMP_BORLAND`] + +[@http://en.wikipedia.org/wiki/C_plus_plus_builder Borland C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__BORLANDC__`] [__predef_detection__]] + [[`__CODEGEARC__`] [__predef_detection__]] + + [[`__BORLANDC__`] [V.R.P]] + [[`__CODEGEARC__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_BORLAND BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__BORLANDC__) || defined(__CODEGEARC__) +# if !defined(BOOST_COMP_BORLAND_DETECTION) && (defined(__CODEGEARC__)) +# define BOOST_COMP_BORLAND_DETECTION BOOST_PREDEF_MAKE_0X_VVRP(__CODEGEARC__) +# endif +# if !defined(BOOST_COMP_BORLAND_DETECTION) +# define BOOST_COMP_BORLAND_DETECTION BOOST_PREDEF_MAKE_0X_VVRP(__BORLANDC__) +# endif +#endif + +#ifdef BOOST_COMP_BORLAND_DETECTION +# define BOOST_COMP_BORLAND_AVAILABLE +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_BORLAND_EMULATED BOOST_COMP_BORLAND_DETECTION +# else +# undef BOOST_COMP_BORLAND +# define BOOST_COMP_BORLAND BOOST_COMP_BORLAND_DETECTION +# endif +# include +#endif + +#define BOOST_COMP_BORLAND_NAME "Borland C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_BORLAND,BOOST_COMP_BORLAND_NAME) + +#ifdef BOOST_COMP_BORLAND_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_BORLAND_EMULATED,BOOST_COMP_BORLAND_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/clang.h b/src/thirdparty/boost_lib/boost/predef/compiler/clang.h new file mode 100644 index 000000000..87dd033c5 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/clang.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_CLANG_H +#define BOOST_PREDEF_COMPILER_CLANG_H + +#include +#include + +/*` +[heading `BOOST_COMP_CLANG`] + +[@http://en.wikipedia.org/wiki/Clang Clang] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__clang__`] [__predef_detection__]] + + [[`__clang_major__`, `__clang_minor__`, `__clang_patchlevel__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_CLANG BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__clang__) +# define BOOST_COMP_CLANG_DETECTION BOOST_VERSION_NUMBER(__clang_major__,__clang_minor__,__clang_patchlevel__) +#endif + +#ifdef BOOST_COMP_CLANG_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_CLANG_EMULATED BOOST_COMP_CLANG_DETECTION +# else +# undef BOOST_COMP_CLANG +# define BOOST_COMP_CLANG BOOST_COMP_CLANG_DETECTION +# endif +# define BOOST_COMP_CLANG_AVAILABLE +# include +#endif + +#define BOOST_COMP_CLANG_NAME "Clang" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_CLANG,BOOST_COMP_CLANG_NAME) + +#ifdef BOOST_COMP_CLANG_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_CLANG_EMULATED,BOOST_COMP_CLANG_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/comeau.h b/src/thirdparty/boost_lib/boost/predef/compiler/comeau.h new file mode 100644 index 000000000..386218404 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/comeau.h @@ -0,0 +1,62 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_COMEAU_H +#define BOOST_PREDEF_COMPILER_COMEAU_H + +#include +#include + +#define BOOST_COMP_COMO BOOST_VERSION_NUMBER_NOT_AVAILABLE + +/*` +[heading `BOOST_COMP_COMO`] + +[@http://en.wikipedia.org/wiki/Comeau_C/C%2B%2B Comeau C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__COMO__`] [__predef_detection__]] + + [[`__COMO_VERSION__`] [V.R.P]] + ] + */ + +#if defined(__COMO__) +# if !defined(BOOST_COMP_COMO_DETECTION) && defined(__CONO_VERSION__) +# define BOOST_COMP_COMO_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__COMO_VERSION__) +# endif +# if !defined(BOOST_COMP_COMO_DETECTION) +# define BOOST_COMP_COMO_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_COMO_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_COMO_EMULATED BOOST_COMP_COMO_DETECTION +# else +# undef BOOST_COMP_COMO +# define BOOST_COMP_COMO BOOST_COMP_COMO_DETECTION +# endif +# define BOOST_COMP_COMO_AVAILABLE +# include +#endif + +#define BOOST_COMP_COMO_NAME "Comeau C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_COMO,BOOST_COMP_COMO_NAME) + +#ifdef BOOST_COMP_COMO_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_COMO_EMULATED,BOOST_COMP_COMO_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/compaq.h b/src/thirdparty/boost_lib/boost/predef/compiler/compaq.h new file mode 100644 index 000000000..a922d170f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/compaq.h @@ -0,0 +1,67 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_COMPAQ_H +#define BOOST_PREDEF_COMPILER_COMPAQ_H + +#include +#include + +/*` +[heading `BOOST_COMP_DEC`] + +[@http://www.openvms.compaq.com/openvms/brochures/deccplus/ Compaq C/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__DECCXX`] [__predef_detection__]] + [[`__DECC`] [__predef_detection__]] + + [[`__DECCXX_VER`] [V.R.P]] + [[`__DECC_VER`] [V.R.P]] + ] + */ + +#define BOOST_COMP_DEC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__DECC) || defined(__DECCXX) +# if !defined(BOOST_COMP_DEC_DETECTION) && defined(__DECCXX_VER) +# define BOOST_COMP_DEC_DETECTION BOOST_PREDEF_MAKE_10_VVRR0PP00(__DECCXX_VER) +# endif +# if !defined(BOOST_COMP_DEC_DETECTION) && defined(__DECC_VER) +# define BOOST_COMP_DEC_DETECTION BOOST_PREDEF_MAKE_10_VVRR0PP00(__DECC_VER) +# endif +# if !defined(BOOST_COMP_DEC_DETECTION) +# define BOOST_COM_DEC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_DEC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_DEC_EMULATED BOOST_COMP_DEC_DETECTION +# else +# undef BOOST_COMP_DEC +# define BOOST_COMP_DEC BOOST_COMP_DEC_DETECTION +# endif +# define BOOST_COMP_DEC_AVAILABLE +# include +#endif + +#define BOOST_COMP_DEC_NAME "Compaq C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DEC,BOOST_COMP_DEC_NAME) + +#ifdef BOOST_COMP_DEC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DEC_EMULATED,BOOST_COMP_DEC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/diab.h b/src/thirdparty/boost_lib/boost/predef/compiler/diab.h new file mode 100644 index 000000000..2cba03b97 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/diab.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_DIAB_H +#define BOOST_PREDEF_COMPILER_DIAB_H + +#include +#include + +/*` +[heading `BOOST_COMP_DIAB`] + +[@http://www.windriver.com/products/development_suite/wind_river_compiler/ Diab C/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__DCC__`] [__predef_detection__]] + + [[`__VERSION_NUMBER__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_DIAB BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__DCC__) +# define BOOST_COMP_DIAB_DETECTION BOOST_PREDEF_MAKE_10_VRPP(__VERSION_NUMBER__) +#endif + +#ifdef BOOST_COMP_DIAB_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_DIAB_EMULATED BOOST_COMP_DIAB_DETECTION +# else +# undef BOOST_COMP_DIAB +# define BOOST_COMP_DIAB BOOST_COMP_DIAB_DETECTION +# endif +# define BOOST_COMP_DIAB_AVAILABLE +# include +#endif + +#define BOOST_COMP_DIAB_NAME "Diab C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DIAB,BOOST_COMP_DIAB_NAME) + +#ifdef BOOST_COMP_DIAB_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DIAB_EMULATED,BOOST_COMP_DIAB_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/digitalmars.h b/src/thirdparty/boost_lib/boost/predef/compiler/digitalmars.h new file mode 100644 index 000000000..2306a7e3a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/digitalmars.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_DIGITALMARS_H +#define BOOST_PREDEF_COMPILER_DIGITALMARS_H + +#include +#include + +/*` +[heading `BOOST_COMP_DMC`] + +[@http://en.wikipedia.org/wiki/Digital_Mars Digital Mars] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__DMC__`] [__predef_detection__]] + + [[`__DMC__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_DMC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__DMC__) +# define BOOST_COMP_DMC_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__DMC__) +#endif + +#ifdef BOOST_COMP_DMC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_DMC_EMULATED BOOST_COMP_DMC_DETECTION +# else +# undef BOOST_COMP_DMC +# define BOOST_COMP_DMC BOOST_COMP_DMC_DETECTION +# endif +# define BOOST_COMP_DMC_AVAILABLE +# include +#endif + +#define BOOST_COMP_DMC_NAME "Digital Mars" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DMC,BOOST_COMP_DMC_NAME) + +#ifdef BOOST_COMP_DMC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DMC_EMULATED,BOOST_COMP_DMC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/dignus.h b/src/thirdparty/boost_lib/boost/predef/compiler/dignus.h new file mode 100644 index 000000000..33c3560f9 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/dignus.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_DIGNUS_H +#define BOOST_PREDEF_COMPILER_DIGNUS_H + +#include +#include + +/*` +[heading `BOOST_COMP_SYSC`] + +[@http://www.dignus.com/dcxx/ Dignus Systems/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__SYSC__`] [__predef_detection__]] + + [[`__SYSC_VER__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_SYSC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__SYSC__) +# define BOOST_COMP_SYSC_DETECTION BOOST_PREDEF_MAKE_10_VRRPP(__SYSC_VER__) +#endif + +#ifdef BOOST_COMP_SYSC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_SYSC_EMULATED BOOST_COMP_SYSC_DETECTION +# else +# undef BOOST_COMP_SYSC +# define BOOST_COMP_SYSC BOOST_COMP_SYSC_DETECTION +# endif +# define BOOST_COMP_SYSC_AVAILABLE +# include +#endif + +#define BOOST_COMP_SYSC_NAME "Dignus Systems/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SYSC,BOOST_COMP_SYSC_NAME) + +#ifdef BOOST_COMP_SYSC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SYSC_EMULATED,BOOST_COMP_SYSC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/edg.h b/src/thirdparty/boost_lib/boost/predef/compiler/edg.h new file mode 100644 index 000000000..d53a5ffba --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/edg.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_EDG_H +#define BOOST_PREDEF_COMPILER_EDG_H + +#include +#include + +/*` +[heading `BOOST_COMP_EDG`] + +[@http://en.wikipedia.org/wiki/Edison_Design_Group EDG C++ Frontend] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__EDG__`] [__predef_detection__]] + + [[`__EDG_VERSION__`] [V.R.0]] + ] + */ + +#define BOOST_COMP_EDG BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__EDG__) +# define BOOST_COMP_EDG_DETECTION BOOST_PREDEF_MAKE_10_VRR(__EDG_VERSION__) +#endif + +#ifdef BOOST_COMP_EDG_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_EDG_EMULATED BOOST_COMP_EDG_DETECTION +# else +# undef BOOST_COMP_EDG +# define BOOST_COMP_EDG BOOST_COMP_EDG_DETECTION +# endif +# define BOOST_COMP_EDG_AVAILABLE +# include +#endif + +#define BOOST_COMP_EDG_NAME "EDG C++ Frontend" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_EDG,BOOST_COMP_EDG_NAME) + +#ifdef BOOST_COMP_EDG_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_EDG_EMULATED,BOOST_COMP_EDG_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/ekopath.h b/src/thirdparty/boost_lib/boost/predef/compiler/ekopath.h new file mode 100644 index 000000000..4d7dabea7 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/ekopath.h @@ -0,0 +1,58 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_EKOPATH_H +#define BOOST_PREDEF_COMPILER_EKOPATH_H + +#include +#include + +/*` +[heading `BOOST_COMP_PATH`] + +[@http://en.wikipedia.org/wiki/PathScale EKOpath] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__PATHCC__`] [__predef_detection__]] + + [[`__PATHCC__`, `__PATHCC_MINOR__`, `__PATHCC_PATCHLEVEL__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_PATH BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__PATHCC__) +# define BOOST_COMP_PATH_DETECTION \ + BOOST_VERSION_NUMBER(__PATHCC__,__PATHCC_MINOR__,__PATHCC_PATCHLEVEL__) +#endif + +#ifdef BOOST_COMP_PATH_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_PATH_EMULATED BOOST_COMP_PATH_DETECTION +# else +# undef BOOST_COMP_PATH +# define BOOST_COMP_PATH BOOST_COMP_PATH_DETECTION +# endif +# define BOOST_COMP_PATH_AVAILABLE +# include +#endif + +#define BOOST_COMP_PATH_NAME "EKOpath" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PATH,BOOST_COMP_PATH_NAME) + +#ifdef BOOST_COMP_PATH_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PATH_EMULATED,BOOST_COMP_PATH_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/gcc.h b/src/thirdparty/boost_lib/boost/predef/compiler/gcc.h new file mode 100644 index 000000000..5b226bdfa --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/gcc.h @@ -0,0 +1,69 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_GCC_H +#define BOOST_PREDEF_COMPILER_GCC_H + +/* Other compilers that emulate this one need to be detected first. */ + +#include + +#include +#include + +/*` +[heading `BOOST_COMP_GNUC`] + +[@http://en.wikipedia.org/wiki/GNU_Compiler_Collection Gnu GCC C/C++] compiler. +Version number available as major, minor, and patch (if available). + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__GNUC__`] [__predef_detection__]] + + [[`__GNUC__`, `__GNUC_MINOR__`, `__GNUC_PATCHLEVEL__`] [V.R.P]] + [[`__GNUC__`, `__GNUC_MINOR__`] [V.R.0]] + ] + */ + +#define BOOST_COMP_GNUC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__GNUC__) +# if !defined(BOOST_COMP_GNUC_DETECTION) && defined(__GNUC_PATCHLEVEL__) +# define BOOST_COMP_GNUC_DETECTION \ + BOOST_VERSION_NUMBER(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__) +# endif +# if !defined(BOOST_COMP_GNUC_DETECTION) +# define BOOST_COMP_GNUC_DETECTION \ + BOOST_VERSION_NUMBER(__GNUC__,__GNUC_MINOR__,0) +# endif +#endif + +#ifdef BOOST_COMP_GNUC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_GNUC_EMULATED BOOST_COMP_GNUC_DETECTION +# else +# undef BOOST_COMP_GNUC +# define BOOST_COMP_GNUC BOOST_COMP_GNUC_DETECTION +# endif +# define BOOST_COMP_GNUC_AVAILABLE +# include +#endif + +#define BOOST_COMP_GNUC_NAME "Gnu GCC C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GNUC,BOOST_COMP_GNUC_NAME) + +#ifdef BOOST_COMP_GNUC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GNUC_EMULATED,BOOST_COMP_GNUC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/gcc_xml.h b/src/thirdparty/boost_lib/boost/predef/compiler/gcc_xml.h new file mode 100644 index 000000000..ef55f5d43 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/gcc_xml.h @@ -0,0 +1,53 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_GCC_XML_H +#define BOOST_PREDEF_COMPILER_GCC_XML_H + +#include +#include + +/*` +[heading `BOOST_COMP_GCCXML`] + +[@http://www.gccxml.org/ GCC XML] compiler. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__GCCXML__`] [__predef_detection__]] + ] + */ + +#define BOOST_COMP_GCCXML BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__GCCXML__) +# define BOOST_COMP_GCCXML_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#ifdef BOOST_COMP_GCCXML_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_GCCXML_EMULATED BOOST_COMP_GCCXML_DETECTION +# else +# undef BOOST_COMP_GCCXML +# define BOOST_COMP_GCCXML BOOST_COMP_GCCXML_DETECTION +# endif +# define BOOST_COMP_GCCXML_AVAILABLE +# include +#endif + +#define BOOST_COMP_GCCXML_NAME "GCC XML" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GCCXML,BOOST_COMP_GCCXML_NAME) + +#ifdef BOOST_COMP_GCCXML_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GCCXML_EMULATED,BOOST_COMP_GCCXML_NAME) +#endif + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/greenhills.h b/src/thirdparty/boost_lib/boost/predef/compiler/greenhills.h new file mode 100644 index 000000000..462f57b61 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/greenhills.h @@ -0,0 +1,67 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_GREENHILLS_H +#define BOOST_PREDEF_COMPILER_GREENHILLS_H + +#include +#include + +/*` +[heading `BOOST_COMP_GHS`] + +[@http://en.wikipedia.org/wiki/Green_Hills_Software Green Hills C/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__ghs`] [__predef_detection__]] + [[`__ghs__`] [__predef_detection__]] + + [[`__GHS_VERSION_NUMBER__`] [V.R.P]] + [[`__ghs`] [V.R.P]] + ] + */ + +#define BOOST_COMP_GHS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__ghs) || defined(__ghs__) +# if !defined(BOOST_COMP_GHS_DETECTION) && defined(__GHS_VERSION_NUMBER__) +# define BOOST_COMP_GHS_DETECTION BOOST_PREDEF_MAKE_10_VRP(__GHS_VERSION_NUMBER__) +# endif +# if !defined(BOOST_COMP_GHS_DETECTION) && defined(__ghs) +# define BOOST_COMP_GHS_DETECTION BOOST_PREDEF_MAKE_10_VRP(__ghs) +# endif +# if !defined(BOOST_COMP_GHS_DETECTION) +# define BOOST_COMP_GHS_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_GHS_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_GHS_EMULATED BOOST_COMP_GHS_DETECTION +# else +# undef BOOST_COMP_GHS +# define BOOST_COMP_GHS BOOST_COMP_GHS_DETECTION +# endif +# define BOOST_COMP_GHS_AVAILABLE +# include +#endif + +#define BOOST_COMP_GHS_NAME "Green Hills C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GHS,BOOST_COMP_GHS_NAME) + +#ifdef BOOST_COMP_GHS_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GHS_EMULATED,BOOST_COMP_GHS_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/hp_acc.h b/src/thirdparty/boost_lib/boost/predef/compiler/hp_acc.h new file mode 100644 index 000000000..8cb7022d3 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/hp_acc.h @@ -0,0 +1,62 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_HP_ACC_H +#define BOOST_PREDEF_COMPILER_HP_ACC_H + +#include +#include + +/*` +[heading `BOOST_COMP_HPACC`] + +HP aC++ compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__HP_aCC`] [__predef_detection__]] + + [[`__HP_aCC`] [V.R.P]] + ] + */ + +#define BOOST_COMP_HPACC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__HP_aCC) +# if !defined(BOOST_COMP_HPACC_DETECTION) && (__HP_aCC > 1) +# define BOOST_COMP_HPACC_DETECTION BOOST_PREDEF_MAKE_10_VVRRPP(__HP_aCC) +# endif +# if !defined(BOOST_COMP_HPACC_DETECTION) +# define BOOST_COMP_HPACC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_HPACC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_HPACC_EMULATED BOOST_COMP_HPACC_DETECTION +# else +# undef BOOST_COMP_HPACC +# define BOOST_COMP_HPACC BOOST_COMP_HPACC_DETECTION +# endif +# define BOOST_COMP_HPACC_AVAILABLE +# include +#endif + +#define BOOST_COMP_HPACC_NAME "HP aC++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HPACC,BOOST_COMP_HPACC_NAME) + +#ifdef BOOST_COMP_HPACC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HPACC_EMULATED,BOOST_COMP_HPACC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/iar.h b/src/thirdparty/boost_lib/boost/predef/compiler/iar.h new file mode 100644 index 000000000..dd6bc0e09 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/iar.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_IAR_H +#define BOOST_PREDEF_COMPILER_IAR_H + +#include +#include + +/*` +[heading `BOOST_COMP_IAR`] + +IAR C/C++ compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__IAR_SYSTEMS_ICC__`] [__predef_detection__]] + + [[`__VER__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_IAR BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__IAR_SYSTEMS_ICC__) +# define BOOST_COMP_IAR_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__VER__) +#endif + +#ifdef BOOST_COMP_IAR_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_IAR_EMULATED BOOST_COMP_IAR_DETECTION +# else +# undef BOOST_COMP_IAR +# define BOOST_COMP_IAR BOOST_COMP_IAR_DETECTION +# endif +# define BOOST_COMP_IAR_AVAILABLE +# include +#endif + +#define BOOST_COMP_IAR_NAME "IAR C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IAR,BOOST_COMP_IAR_NAME) + +#ifdef BOOST_COMP_IAR_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IAR_EMULATED,BOOST_COMP_IAR_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/ibm.h b/src/thirdparty/boost_lib/boost/predef/compiler/ibm.h new file mode 100644 index 000000000..1edc93c36 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/ibm.h @@ -0,0 +1,73 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_IBM_H +#define BOOST_PREDEF_COMPILER_IBM_H + +#include +#include + +/*` +[heading `BOOST_COMP_IBM`] + +[@http://en.wikipedia.org/wiki/VisualAge IBM XL C/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__IBMCPP__`] [__predef_detection__]] + [[`__xlC__`] [__predef_detection__]] + [[`__xlc__`] [__predef_detection__]] + + [[`__COMPILER_VER__`] [V.R.P]] + [[`__xlC__`] [V.R.P]] + [[`__xlc__`] [V.R.P]] + [[`__IBMCPP__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_IBM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__IBMCPP__) || defined(__xlC__) || defined(__xlc__) +# if !defined(BOOST_COMP_IBM_DETECTION) && defined(__COMPILER_VER__) +# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_0X_VRRPPPP(__COMPILER_VER__) +# endif +# if !defined(BOOST_COMP_IBM_DETECTION) && defined(__xlC__) +# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_0X_VVRR(__xlC__) +# endif +# if !defined(BOOST_COMP_IBM_DETECTION) && defined(__xlc__) +# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_0X_VVRR(__xlc__) +# endif +# if !defined(BOOST_COMP_IBM_DETECTION) +# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_10_VRP(__IBMCPP__) +# endif +#endif + +#ifdef BOOST_COMP_IBM_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_IBM_EMULATED BOOST_COMP_IBM_DETECTION +# else +# undef BOOST_COMP_IBM +# define BOOST_COMP_IBM BOOST_COMP_IBM_DETECTION +# endif +# define BOOST_COMP_IBM_AVAILABLE +# include +#endif + +#define BOOST_COMP_IBM_NAME "IBM XL C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IBM,BOOST_COMP_IBM_NAME) + +#ifdef BOOST_COMP_IBM_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IBM_EMULATED,BOOST_COMP_IBM_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/intel.h b/src/thirdparty/boost_lib/boost/predef/compiler/intel.h new file mode 100644 index 000000000..60220c7bf --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/intel.h @@ -0,0 +1,66 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_INTEL_H +#define BOOST_PREDEF_COMPILER_INTEL_H + +#include +#include + +/*` +[heading `BOOST_COMP_INTEL`] + +[@http://en.wikipedia.org/wiki/Intel_C%2B%2B Intel C/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__INTEL_COMPILER`] [__predef_detection__]] + [[`__ICL`] [__predef_detection__]] + [[`__ICC`] [__predef_detection__]] + [[`__ECC`] [__predef_detection__]] + + [[`__INTEL_COMPILER`] [V.R.P]] + ] + */ + +#define BOOST_COMP_INTEL BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || \ + defined(__ECC) +# if !defined(BOOST_COMP_INTEL_DETECTION) && defined(__INTEL_COMPILER) +# define BOOST_COMP_INTEL_DETECTION BOOST_PREDEF_MAKE_10_VRP(__INTEL_COMPILER) +# endif +# if !defined(BOOST_COMP_INTEL_DETECTION) +# define BOOST_COMP_INTEL_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_INTEL_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_INTEL_EMULATED BOOST_COMP_INTEL_DETECTION +# else +# undef BOOST_COMP_INTEL +# define BOOST_COMP_INTEL BOOST_COMP_INTEL_DETECTION +# endif +# define BOOST_COMP_INTEL_AVAILABLE +# include +#endif + +#define BOOST_COMP_INTEL_NAME "Intel C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_INTEL,BOOST_COMP_INTEL_NAME) + +#ifdef BOOST_COMP_INTEL_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_INTEL_EMULATED,BOOST_COMP_INTEL_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/kai.h b/src/thirdparty/boost_lib/boost/predef/compiler/kai.h new file mode 100644 index 000000000..4aadbe329 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/kai.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_KAI_H +#define BOOST_PREDEF_COMPILER_KAI_H + +#include +#include + +/*` +[heading `BOOST_COMP_KCC`] + +Kai C++ compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__KCC`] [__predef_detection__]] + + [[`__KCC_VERSION`] [V.R.P]] + ] + */ + +#define BOOST_COMP_KCC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__KCC) +# define BOOST_COMP_KCC_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__KCC_VERSION) +#endif + +#ifdef BOOST_COMP_KCC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_KCC_EMULATED BOOST_COMP_KCC_DETECTION +# else +# undef BOOST_COMP_KCC +# define BOOST_COMP_KCC BOOST_COMP_KCC_DETECTION +# endif +# define BOOST_COMP_KCC_AVAILABLE +# include +#endif + +#define BOOST_COMP_KCC_NAME "Kai C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_KCC,BOOST_COMP_KCC_NAME) + +#ifdef BOOST_COMP_KCC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_KCC_EMULATED,BOOST_COMP_KCC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/llvm.h b/src/thirdparty/boost_lib/boost/predef/compiler/llvm.h new file mode 100644 index 000000000..c7e634c31 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/llvm.h @@ -0,0 +1,58 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_LLVM_H +#define BOOST_PREDEF_COMPILER_LLVM_H + +/* Other compilers that emulate this one need to be detected first. */ + +#include + +#include +#include + +/*` +[heading `BOOST_COMP_LLVM`] + +[@http://en.wikipedia.org/wiki/LLVM LLVM] compiler. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__llvm__`] [__predef_detection__]] + ] + */ + +#define BOOST_COMP_LLVM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__llvm__) +# define BOOST_COMP_LLVM_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#ifdef BOOST_COMP_LLVM_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_LLVM_EMULATED BOOST_COMP_LLVM_DETECTION +# else +# undef BOOST_COMP_LLVM +# define BOOST_COMP_LLVM BOOST_COMP_LLVM_DETECTION +# endif +# define BOOST_COMP_LLVM_AVAILABLE +# include +#endif + +#define BOOST_COMP_LLVM_NAME "LLVM" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_LLVM,BOOST_COMP_LLVM_NAME) + +#ifdef BOOST_COMP_LLVM_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_LLVM_EMULATED,BOOST_COMP_LLVM_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/metaware.h b/src/thirdparty/boost_lib/boost/predef/compiler/metaware.h new file mode 100644 index 000000000..5e13de854 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/metaware.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_METAWARE_H +#define BOOST_PREDEF_COMPILER_METAWARE_H + +#include +#include + +/*` +[heading `BOOST_COMP_HIGHC`] + +MetaWare High C/C++ compiler. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__HIGHC__`] [__predef_detection__]] + ] + */ + +#define BOOST_COMP_HIGHC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__HIGHC__) +# define BOOST_COMP_HIGHC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#ifdef BOOST_COMP_HIGHC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_HIGHC_EMULATED BOOST_COMP_HIGHC_DETECTION +# else +# undef BOOST_COMP_HIGHC +# define BOOST_COMP_HIGHC BOOST_COMP_HIGHC_DETECTION +# endif +# define BOOST_COMP_HIGHC_AVAILABLE +# include +#endif + +#define BOOST_COMP_HIGHC_NAME "MetaWare High C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HIGHC,BOOST_COMP_HIGHC_NAME) + +#ifdef BOOST_COMP_HIGHC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HIGHC_EMULATED,BOOST_COMP_HIGHC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/metrowerks.h b/src/thirdparty/boost_lib/boost/predef/compiler/metrowerks.h new file mode 100644 index 000000000..409282b33 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/metrowerks.h @@ -0,0 +1,78 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_METROWERKS_H +#define BOOST_PREDEF_COMPILER_METROWERKS_H + +#include +#include + +/*` +[heading `BOOST_COMP_MWERKS`] + +[@http://en.wikipedia.org/wiki/CodeWarrior Metrowerks CodeWarrior] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MWERKS__`] [__predef_detection__]] + [[`__CWCC__`] [__predef_detection__]] + + [[`__CWCC__`] [V.R.P]] + [[`__MWERKS__`] [V.R.P >= 4.2.0]] + [[`__MWERKS__`] [9.R.0]] + [[`__MWERKS__`] [8.R.0]] + ] + */ + +#define BOOST_COMP_MWERKS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__MWERKS__) || defined(__CWCC__) +# if !defined(BOOST_COMP_MWERKS_DETECTION) && defined(__CWCC__) +# define BOOST_COMP_MWERKS_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__CWCC__) +# endif +# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x4200) +# define BOOST_COMP_MWERKS_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__MWERKS__) +# endif +# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x3204) // note the "skip": 04->9.3 +# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER(9,(__MWERKS__)%100-1,0) +# endif +# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x3200) +# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER(9,(__MWERKS__)%100,0) +# endif +# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x3000) +# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER(8,(__MWERKS__)%100,0) +# endif +# if !defined(BOOST_COMP_MWERKS_DETECTION) +# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_MWERKS_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_MWERKS_EMULATED BOOST_COMP_MWERKS_DETECTION +# else +# undef BOOST_COMP_MWERKS +# define BOOST_COMP_MWERKS BOOST_COMP_MWERKS_DETECTION +# endif +# define BOOST_COMP_MWERKS_AVAILABLE +# include +#endif + +#define BOOST_COMP_MWERKS_NAME "Metrowerks CodeWarrior" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MWERKS,BOOST_COMP_MWERKS_NAME) + +#ifdef BOOST_COMP_MWERKS_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MWERKS_EMULATED,BOOST_COMP_MWERKS_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/microtec.h b/src/thirdparty/boost_lib/boost/predef/compiler/microtec.h new file mode 100644 index 000000000..6bd627905 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/microtec.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_MICROTEC_H +#define BOOST_PREDEF_COMPILER_MICROTEC_H + +#include +#include + +/*` +[heading `BOOST_COMP_MRI`] + +[@http://www.mentor.com/microtec/ Microtec C/C++] compiler. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_MRI`] [__predef_detection__]] + ] + */ + +#define BOOST_COMP_MRI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(_MRI) +# define BOOST_COMP_MRI_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#ifdef BOOST_COMP_MRI_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_MRI_EMULATED BOOST_COMP_MRI_DETECTION +# else +# undef BOOST_COMP_MRI +# define BOOST_COMP_MRI BOOST_COMP_MRI_DETECTION +# endif +# define BOOST_COMP_MRI_AVAILABLE +# include +#endif + +#define BOOST_COMP_MRI_NAME "Microtec C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MRI,BOOST_COMP_MRI_NAME) + +#ifdef BOOST_COMP_MRI_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MRI_EMULATED,BOOST_COMP_MRI_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/mpw.h b/src/thirdparty/boost_lib/boost/predef/compiler/mpw.h new file mode 100644 index 000000000..3a48f6f74 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/mpw.h @@ -0,0 +1,64 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_MPW_H +#define BOOST_PREDEF_COMPILER_MPW_H + +#include +#include + +/*` +[heading `BOOST_COMP_MPW`] + +[@http://en.wikipedia.org/wiki/Macintosh_Programmer%27s_Workshop MPW C++] compiler. +Version number available as major, and minor. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MRC__`] [__predef_detection__]] + [[`MPW_C`] [__predef_detection__]] + [[`MPW_CPLUS`] [__predef_detection__]] + + [[`__MRC__`] [V.R.0]] + ] + */ + +#define BOOST_COMP_MPW BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__MRC__) || defined(MPW_C) || defined(MPW_CPLUS) +# if !defined(BOOST_COMP_MPW_DETECTION) && defined(__MRC__) +# define BOOST_COMP_MPW_DETECTION BOOST_PREDEF_MAKE_0X_VVRR(__MRC__) +# endif +# if !defined(BOOST_COMP_MPW_DETECTION) +# define BOOST_COMP_MPW_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_MPW_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_MPW_EMULATED BOOST_COMP_MPW_DETECTION +# else +# undef BOOST_COMP_MPW +# define BOOST_COMP_MPW BOOST_COMP_MPW_DETECTION +# endif +# define BOOST_COMP_MPW_AVAILABLE +# include +#endif + +#define BOOST_COMP_MPW_NAME "MPW C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MPW,BOOST_COMP_MPW_NAME) + +#ifdef BOOST_COMP_MPW_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MPW_EMULATED,BOOST_COMP_MPW_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/palm.h b/src/thirdparty/boost_lib/boost/predef/compiler/palm.h new file mode 100644 index 000000000..eb1da971c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/palm.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_PALM_H +#define BOOST_PREDEF_COMPILER_PALM_H + +#include +#include + +/*` +[heading `BOOST_COMP_PALM`] + +Palm C/C++ compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_PACC_VER`] [__predef_detection__]] + + [[`_PACC_VER`] [V.R.P]] + ] + */ + +#define BOOST_COMP_PALM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(_PACC_VER) +# define BOOST_COMP_PALM_DETECTION BOOST_PREDEF_MAKE_0X_VRRPP000(_PACC_VER) +#endif + +#ifdef BOOST_COMP_PALM_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_PALM_EMULATED BOOST_COMP_PALM_DETECTION +# else +# undef BOOST_COMP_PALM +# define BOOST_COMP_PALM BOOST_COMP_PALM_DETECTION +# endif +# define BOOST_COMP_PALM_AVAILABLE +# include +#endif + +#define BOOST_COMP_PALM_NAME "Palm C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PALM,BOOST_COMP_PALM_NAME) + +#ifdef BOOST_COMP_PALM_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PALM_EMULATED,BOOST_COMP_PALM_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/pgi.h b/src/thirdparty/boost_lib/boost/predef/compiler/pgi.h new file mode 100644 index 000000000..563335ff3 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/pgi.h @@ -0,0 +1,61 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_PGI_H +#define BOOST_PREDEF_COMPILER_PGI_H + +#include +#include + +/*` +[heading `BOOST_COMP_PGI`] + +[@http://en.wikipedia.org/wiki/The_Portland_Group Portland Group C/C++] compiler. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__PGI`] [__predef_detection__]] + + [[`__PGIC__`, `__PGIC_MINOR__`, `__PGIC_PATCHLEVEL__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_PGI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__PGI) +# if !defined(BOOST_COMP_PGI_DETECTION) && (defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)) +# define BOOST_COMP_PGI_DETECTION BOOST_VERSION_NUMBER(__PGIC__,__PGIC_MINOR__,__PGIC_PATCHLEVEL__) +# endif +# if !defined(BOOST_COMP_PGI_DETECTION) +# define BOOST_COMP_PGI_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_PGI_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_PGI_EMULATED BOOST_COMP_PGI_DETECTION +# else +# undef BOOST_COMP_PGI +# define BOOST_COMP_PGI BOOST_COMP_PGI_DETECTION +# endif +# define BOOST_COMP_PGI_AVAILABLE +# include +#endif + +#define BOOST_COMP_PGI_NAME "Portland Group C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PGI,BOOST_COMP_PGI_NAME) + +#ifdef BOOST_COMP_PGI_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PGI_EMULATED,BOOST_COMP_PGI_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/sgi_mipspro.h b/src/thirdparty/boost_lib/boost/predef/compiler/sgi_mipspro.h new file mode 100644 index 000000000..c212b19f4 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/sgi_mipspro.h @@ -0,0 +1,67 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_SGI_MIPSPRO_H +#define BOOST_PREDEF_COMPILER_SGI_MIPSPRO_H + +#include +#include + +/*` +[heading `BOOST_COMP_SGI`] + +[@http://en.wikipedia.org/wiki/MIPSpro SGI MIPSpro] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__sgi`] [__predef_detection__]] + [[`sgi`] [__predef_detection__]] + + [[`_SGI_COMPILER_VERSION`] [V.R.P]] + [[`_COMPILER_VERSION`] [V.R.P]] + ] + */ + +#define BOOST_COMP_SGI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__sgi) || defined(sgi) +# if !defined(BOOST_COMP_SGI_DETECTION) && defined(_SGI_COMPILER_VERSION) +# define BOOST_COMP_SGI_DETECTION BOOST_PREDEF_MAKE_10_VRP(_SGI_COMPILER_VERSION) +# endif +# if !defined(BOOST_COMP_SGI_DETECTION) && defined(_COMPILER_VERSION) +# define BOOST_COMP_SGI_DETECTION BOOST_PREDEF_MAKE_10_VRP(_COMPILER_VERSION) +# endif +# if !defined(BOOST_COMP_SGI_DETECTION) +# define BOOST_COMP_SGI_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_SGI_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_SGI_EMULATED BOOST_COMP_SGI_DETECTION +# else +# undef BOOST_COMP_SGI +# define BOOST_COMP_SGI BOOST_COMP_SGI_DETECTION +# endif +# define BOOST_COMP_SGI_AVAILABLE +# include +#endif + +#define BOOST_COMP_SGI_NAME "SGI MIPSpro" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SGI,BOOST_COMP_SGI_NAME) + +#ifdef BOOST_COMP_SGI_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SGI_EMULATED,BOOST_COMP_SGI_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/sunpro.h b/src/thirdparty/boost_lib/boost/predef/compiler/sunpro.h new file mode 100644 index 000000000..bd3da279d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/sunpro.h @@ -0,0 +1,67 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_SUNPRO_H +#define BOOST_PREDEF_COMPILER_SUNPRO_H + +#include +#include + +/*` +[heading `BOOST_COMP_SUNPRO`] + +[@http://en.wikipedia.org/wiki/Sun_Studio_%28software%29 Sun Studio] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__SUNPRO_CC`] [__predef_detection__]] + [[`__SUNPRO_C`] [__predef_detection__]] + + [[`__SUNPRO_CC`] [V.R.P]] + [[`__SUNPRO_C`] [V.R.P]] + ] + */ + +#define BOOST_COMP_SUNPRO BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__SUNPRO_CC) || defined(__SUNPRO_C) +# if !defined(BOOST_COMP_SUNPRO_DETECTION) && defined(__SUNPRO_CC) +# define BOOST_COMP_SUNPRO_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__SUNPRO_CC) +# endif +# if !defined(BOOST_COMP_SUNPRO_DETECTION) && defined(__SUNPRO_C) +# define BOOST_COMP_SUNPRO_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__SUNPRO_C) +# endif +# if !defined(BOOST_COMP_SUNPRO_DETECTION) +# define BOOST_COMP_SUNPRO_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_COMP_SUNPRO_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_SUNPRO_EMULATED BOOST_COMP_SUNPRO_DETECTION +# else +# undef BOOST_COMP_SUNPRO +# define BOOST_COMP_SUNPRO BOOST_COMP_SUNPRO_DETECTION +# endif +# define BOOST_COMP_SUNPRO_AVAILABLE +# include +#endif + +#define BOOST_COMP_SUNPRO_NAME "Sun Studio" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SUNPRO,BOOST_COMP_SUNPRO_NAME) + +#ifdef BOOST_COMP_SUNPRO_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SUNPRO_EMULATED,BOOST_COMP_SUNPRO_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/tendra.h b/src/thirdparty/boost_lib/boost/predef/compiler/tendra.h new file mode 100644 index 000000000..194f0af83 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/tendra.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_TENDRA_H +#define BOOST_PREDEF_COMPILER_TENDRA_H + +#include +#include + +/*` +[heading `BOOST_COMP_TENDRA`] + +[@http://en.wikipedia.org/wiki/TenDRA_Compiler TenDRA C/C++] compiler. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__TenDRA__`] [__predef_detection__]] + ] + */ + +#define BOOST_COMP_TENDRA BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__TenDRA__) +# define BOOST_COMP_TENDRA_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#ifdef BOOST_COMP_TENDRA_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_TENDRA_EMULATED BOOST_COMP_TENDRA_DETECTION +# else +# undef BOOST_COMP_TENDRA +# define BOOST_COMP_TENDRA BOOST_COMP_TENDRA_DETECTION +# endif +# define BOOST_COMP_TENDRA_AVAILABLE +# include +#endif + +#define BOOST_COMP_TENDRA_NAME "TenDRA C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_TENDRA,BOOST_COMP_TENDRA_NAME) + +#ifdef BOOST_COMP_TENDRA_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_TENDRA_EMULATED,BOOST_COMP_TENDRA_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/visualc.h b/src/thirdparty/boost_lib/boost/predef/compiler/visualc.h new file mode 100644 index 000000000..66d060107 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/visualc.h @@ -0,0 +1,79 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_VISUALC_H +#define BOOST_PREDEF_COMPILER_VISUALC_H + +/* Other compilers that emulate this one need to be detected first. */ + +#include + +#include +#include + +/*` +[heading `BOOST_COMP_MSVC`] + +[@http://en.wikipedia.org/wiki/Visual_studio Microsoft Visual C/C++] compiler. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_MSC_VER`] [__predef_detection__]] + + [[`_MSC_FULL_VER`] [V.R.P]] + [[`_MSC_VER`] [V.R.0]] + ] + */ + +#define BOOST_COMP_MSVC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(_MSC_VER) +# if !defined (_MSC_FULL_VER) +# define BOOST_COMP_MSVC_BUILD 0 +# else + /* how many digits does the build number have? */ +# if _MSC_FULL_VER / 10000 == _MSC_VER + /* four digits */ +# define BOOST_COMP_MSVC_BUILD (_MSC_FULL_VER % 10000) +# elif _MSC_FULL_VER / 100000 == _MSC_VER + /* five digits */ +# define BOOST_COMP_MSVC_BUILD (_MSC_FULL_VER % 100000) +# else +# error "Cannot determine build number from _MSC_FULL_VER" +# endif +# endif +# define BOOST_COMP_MSVC_DETECTION BOOST_VERSION_NUMBER(\ + _MSC_VER/100-6,\ + _MSC_VER%100,\ + BOOST_COMP_MSVC_BUILD) +#endif + +#ifdef BOOST_COMP_MSVC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_MSVC_EMULATED BOOST_COMP_MSVC_DETECTION +# else +# undef BOOST_COMP_MSVC +# define BOOST_COMP_MSVC BOOST_COMP_MSVC_DETECTION +# endif +# define BOOST_COMP_MSVC_AVAILABLE +# include +#endif + +#define BOOST_COMP_MSVC_NAME "Microsoft Visual C/C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MSVC,BOOST_COMP_MSVC_NAME) + +#ifdef BOOST_COMP_MSVC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MSVC_EMULATED,BOOST_COMP_MSVC_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/compiler/watcom.h b/src/thirdparty/boost_lib/boost/predef/compiler/watcom.h new file mode 100644 index 000000000..832d10c54 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/compiler/watcom.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_WATCOM_H +#define BOOST_PREDEF_COMPILER_WATCOM_H + +#include +#include + +/*` +[heading `BOOST_COMP_WATCOM`] + +[@http://en.wikipedia.org/wiki/Watcom Watcom C++] compiler. +Version number available as major, and minor. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__WATCOMC__`] [__predef_detection__]] + + [[`__WATCOMC__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_WATCOM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__WATCOMC__) +# define BOOST_COMP_WATCOM_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__WATCOMC__) +#endif + +#ifdef BOOST_COMP_WATCOM_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_WATCOM_EMULATED BOOST_COMP_WATCOM_DETECTION +# else +# undef BOOST_COMP_WATCOM +# define BOOST_COMP_WATCOM BOOST_COMP_WATCOM_DETECTION +# endif +# define BOOST_COMP_WATCOM_AVAILABLE +# include +#endif + +#define BOOST_COMP_WATCOM_NAME "Watcom C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_WATCOM,BOOST_COMP_WATCOM_NAME) + +#ifdef BOOST_COMP_WATCOM_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_WATCOM_EMULATED,BOOST_COMP_WATCOM_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/_cassert.h b/src/thirdparty/boost_lib/boost/predef/detail/_cassert.h new file mode 100644 index 000000000..ccae4950d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/_cassert.h @@ -0,0 +1,17 @@ +/* +Copyright Rene Rivera 2011-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL__CASSERT_H +#define BOOST_PREDEF_DETAIL__CASSERT_H + +#if defined(__cpluplus) +#include +#else +#include +#endif + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/_exception.h b/src/thirdparty/boost_lib/boost/predef/detail/_exception.h new file mode 100644 index 000000000..ca58c79d3 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/_exception.h @@ -0,0 +1,15 @@ +/* +Copyright Rene Rivera 2011-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL__EXCEPTION_H +#define BOOST_PREDEF_DETAIL__EXCEPTION_H + +#if defined(__cpluplus) +#include +#endif + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/comp_detected.h b/src/thirdparty/boost_lib/boost/predef/detail/comp_detected.h new file mode 100644 index 000000000..fda1801b6 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/comp_detected.h @@ -0,0 +1,10 @@ +/* +Copyright Rene Rivera 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL_COMP_DETECTED +#define BOOST_PREDEF_DETAIL_COMP_DETECTED 1 +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/endian_compat.h b/src/thirdparty/boost_lib/boost/predef/detail/endian_compat.h new file mode 100644 index 000000000..7725e6823 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/endian_compat.h @@ -0,0 +1,26 @@ +/* +Copyright Rene Rivera 2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL_ENDIAN_COMPAT_H +#define BOOST_PREDEF_DETAIL_ENDIAN_COMPAT_H + +#include + +#if BOOST_ENDIAN_BIG_BYTE +# define BOOST_BIG_ENDIAN +# define BOOST_BYTE_ORDER 4321 +#endif +#if BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_LITTLE_ENDIAN +# define BOOST_BYTE_ORDER 1234 +#endif +#if BOOST_ENDIAN_LITTLE_WORD +# define BOOST_PDP_ENDIAN +# define BOOST_BYTE_ORDER 2134 +#endif + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/os_detected.h b/src/thirdparty/boost_lib/boost/predef/detail/os_detected.h new file mode 100644 index 000000000..08e10f993 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/os_detected.h @@ -0,0 +1,10 @@ +/* +Copyright Rene Rivera 2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL_OS_DETECTED +#define BOOST_PREDEF_DETAIL_OS_DETECTED 1 +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/platform_detected.h b/src/thirdparty/boost_lib/boost/predef/detail/platform_detected.h new file mode 100644 index 000000000..4faf6938d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/platform_detected.h @@ -0,0 +1,10 @@ +/* +Copyright Rene Rivera 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL_PLAT_DETECTED +#define BOOST_PREDEF_DETAIL_PLAT_DETECTED 1 +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/detail/test.h b/src/thirdparty/boost_lib/boost/predef/detail/test.h new file mode 100644 index 000000000..546a9e407 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/detail/test.h @@ -0,0 +1,17 @@ +/* +Copyright Rene Rivera 2011-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_DETAIL_TEST_H +#define BOOST_PREDEF_DETAIL_TEST_H + +#if !defined(BOOST_PREDEF_INTERNAL_GENERATE_TESTS) + +#define BOOST_PREDEF_DECLARE_TEST(x,s) + +#endif + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/language.h b/src/thirdparty/boost_lib/boost/predef/language.h new file mode 100644 index 000000000..c9251c52a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/language.h @@ -0,0 +1,15 @@ +/* +Copyright Rene Rivera 2011-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LANGUAGE_H +#define BOOST_PREDEF_LANGUAGE_H + +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/language/objc.h b/src/thirdparty/boost_lib/boost/predef/language/objc.h new file mode 100644 index 000000000..27a32b637 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/language/objc.h @@ -0,0 +1,43 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LANGUAGE_OBJC_H +#define BOOST_PREDEF_LANGUAGE_OBJC_H + +#include +#include + +/*` +[heading `BOOST_LANG_OBJC`] + +[@http://en.wikipedia.org/wiki/Objective-C Objective-C] language. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__OBJC__`] [__predef_detection__]] + ] + */ + +#define BOOST_LANG_OBJC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__OBJC__) +# undef BOOST_LANG_OBJC +# define BOOST_LANG_OBJC BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_LANG_OBJC +# define BOOST_LANG_OBJC_AVAILABLE +#endif + +#define BOOST_LANG_OBJC_NAME "Objective-C" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_OBJC,BOOST_LANG_OBJC_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/language/stdc.h b/src/thirdparty/boost_lib/boost/predef/language/stdc.h new file mode 100644 index 000000000..59a4e0bb4 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/language/stdc.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2011-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LANGUAGE_STDC_H +#define BOOST_PREDEF_LANGUAGE_STDC_H + +#include +#include + +/*` +[heading `BOOST_LANG_STDC`] + +[@http://en.wikipedia.org/wiki/C_(programming_language) Standard C] language. +If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__STDC__`] [__predef_detection__]] + + [[`__STDC_VERSION__`] [V.R.P]] + ] + */ + +#define BOOST_LANG_STDC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__STDC__) +# undef BOOST_LANG_STDC +# if defined(__STDC_VERSION__) +# if (__STDC_VERSION__ > 100) +# define BOOST_LANG_STDC BOOST_PREDEF_MAKE_YYYYMM(__STDC_VERSION__) +# else +# define BOOST_LANG_STDC BOOST_VERSION_NUMBER_AVAILABLE +# endif +# else +# define BOOST_LANG_STDC BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LANG_STDC +# define BOOST_LANG_STDC_AVAILABLE +#endif + +#define BOOST_LANG_STDC_NAME "Standard C" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDC,BOOST_LANG_STDC_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/language/stdcpp.h b/src/thirdparty/boost_lib/boost/predef/language/stdcpp.h new file mode 100644 index 000000000..693c67b02 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/language/stdcpp.h @@ -0,0 +1,124 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LANGUAGE_STDCPP_H +#define BOOST_PREDEF_LANGUAGE_STDCPP_H + +#include +#include + +/*` +[heading `BOOST_LANG_STDCPP`] + +[@http://en.wikipedia.org/wiki/C%2B%2B Standard C++] language. +If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date. +Because of the way the C++ standardization process works the +defined version year will not be the commonly known year of the standard. +Specifically the defined versions are: + +[table Detected Version Number vs. C++ Standard Year + [[Detected Version Number] [Standard Year] [C++ Standard]] + [[27.11.1] [1998] [ISO/IEC 14882:1998]] + [[41.12.1] [2011] [ISO/IEC 14882:2011]] +] + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__cplusplus`] [__predef_detection__]] + + [[`__cplusplus`] [YYYY.MM.1]] + ] + */ + +#define BOOST_LANG_STDCPP BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__cplusplus) +# undef BOOST_LANG_STDCPP +# if (__cplusplus > 100) +# define BOOST_LANG_STDCPP BOOST_PREDEF_MAKE_YYYYMM(__cplusplus) +# else +# define BOOST_LANG_STDCPP BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LANG_STDCPP +# define BOOST_LANG_STDCPP_AVAILABLE +#endif + +#define BOOST_LANG_STDCPP_NAME "Standard C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDCPP,BOOST_LANG_STDCPP_NAME) + + +/*` +[heading `BOOST_LANG_STDCPPCLI`] + +[@http://en.wikipedia.org/wiki/C%2B%2B/CLI Standard C++/CLI] language. +If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__cplusplus_cli`] [__predef_detection__]] + + [[`__cplusplus_cli`] [YYYY.MM.1]] + ] + */ + +#define BOOST_LANG_STDCPPCLI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__cplusplus_cli) +# undef BOOST_LANG_STDCPPCLI +# if (__cplusplus_cli > 100) +# define BOOST_LANG_STDCPPCLI BOOST_PREDEF_MAKE_YYYYMM(__cplusplus_cli) +# else +# define BOOST_LANG_STDCPPCLI BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LANG_STDCPPCLI +# define BOOST_LANG_STDCPPCLI_AVAILABLE +#endif + +#define BOOST_LANG_STDCPPCLI_NAME "Standard C++/CLI" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDCPPCLI,BOOST_LANG_STDCPPCLI_NAME) + + +/*` +[heading `BOOST_LANG_STDECPP`] + +[@http://en.wikipedia.org/wiki/Embedded_C%2B%2B Standard Embedded C++] language. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__embedded_cplusplus`] [__predef_detection__]] + ] + */ + +#define BOOST_LANG_STDECPP BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__embedded_cplusplus) +# undef BOOST_LANG_STDECPP +# define BOOST_LANG_STDECPP BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_LANG_STDECPP +# define BOOST_LANG_STDECPP_AVAILABLE +#endif + +#define BOOST_LANG_STDECPP_NAME "Standard Embedded C++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDECPP,BOOST_LANG_STDECPP_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library.h b/src/thirdparty/boost_lib/boost/predef/library.h new file mode 100644 index 000000000..a474323f3 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library.h @@ -0,0 +1,14 @@ +/* +Copyright Rene Rivera 2008-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_H +#define BOOST_PREDEF_LIBRARY_H + +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/c.h b/src/thirdparty/boost_lib/boost/predef/library/c.h new file mode 100644 index 000000000..733e6a7c8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/c.h @@ -0,0 +1,18 @@ +/* +Copyright Rene Rivera 2008-2012 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_C_H +#define BOOST_PREDEF_LIBRARY_C_H + +#include + +#include +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/c/_prefix.h b/src/thirdparty/boost_lib/boost/predef/library/c/_prefix.h new file mode 100644 index 000000000..12bcb0fb3 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/c/_prefix.h @@ -0,0 +1,13 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_C__PREFIX_H +#define BOOST_PREDEF_LIBRARY_C__PREFIX_H + +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/c/gnu.h b/src/thirdparty/boost_lib/boost/predef/library/c/gnu.h new file mode 100644 index 000000000..8ed9f76a3 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/c/gnu.h @@ -0,0 +1,62 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_C_GNU_H +#define BOOST_PREDEF_LIBRARY_C_GNU_H + +#include +#include + +#include + +#if defined(__STDC__) +#include +#elif defined(__cplusplus) +#include +#endif + +/*` +[heading `BOOST_LIB_C_GNU`] + +[@http://en.wikipedia.org/wiki/Glibc GNU glibc] Standard C library. +Version number available as major, and minor. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__GLIBC__`] [__predef_detection__]] + [[`__GNU_LIBRARY__`] [__predef_detection__]] + + [[`__GLIBC__`, `__GLIBC_MINOR__`] [V.R.0]] + [[`__GNU_LIBRARY__`, `__GNU_LIBRARY_MINOR__`] [V.R.0]] + ] + */ + +#define BOOST_LIB_C_GNU BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__GLIBC__) || defined(__GNU_LIBRARY__) +# undef BOOST_LIB_C_GNU +# if defined(__GLIBC__) +# define BOOST_LIB_C_GNU \ + BOOST_VERSION_NUMBER(__GLIBC__,__GLIBC_MINOR__,0) +# else +# define BOOST_LIB_C_GNU \ + BOOST_VERSION_NUMBER(__GNU_LIBRARY__,__GNU_LIBRARY_MINOR__,0) +# endif +#endif + +#if BOOST_LIB_C_GNU +# define BOOST_LIB_C_GNU_AVAILABLE +#endif + +#define BOOST_LIB_C_GNU_NAME "GNU" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_GNU,BOOST_LIB_C_GNU_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/c/uc.h b/src/thirdparty/boost_lib/boost/predef/library/c/uc.h new file mode 100644 index 000000000..8b47de15a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/c/uc.h @@ -0,0 +1,48 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_C_UC_H +#define BOOST_PREDEF_LIBRARY_C_UC_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_C_UC`] + +[@http://en.wikipedia.org/wiki/Uclibc uClibc] Standard C library. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__UCLIBC__`] [__predef_detection__]] + + [[`__UCLIBC_MAJOR__`, `__UCLIBC_MINOR__`, `__UCLIBC_SUBLEVEL__`] [V.R.P]] + ] + */ + +#define BOOST_LIB_C_UC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__UCLIBC__) +# undef BOOST_LIB_C_UC +# define BOOST_LIB_C_UC BOOST_VERSION_NUMBER(\ + __UCLIBC_MAJOR__,__UCLIBC_MINOR__,__UCLIBC_SUBLEVEL__) +#endif + +#if BOOST_LIB_C_UC +# define BOOST_LIB_C_UC_AVAILABLE +#endif + +#define BOOST_LIB_C_UC_NAME "uClibc" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_UC,BOOST_LIB_C_UC_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/c/vms.h b/src/thirdparty/boost_lib/boost/predef/library/c/vms.h new file mode 100644 index 000000000..0357d05e6 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/c/vms.h @@ -0,0 +1,48 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_C_VMS_H +#define BOOST_PREDEF_LIBRARY_C_VMS_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_C_VMS`] + +VMS libc Standard C library. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__CRTL_VER`] [__predef_detection__]] + + [[`__CRTL_VER`] [V.R.P]] + ] + */ + +#define BOOST_LIB_C_VMS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__CRTL_VER) +# undef BOOST_LIB_C_VMS +# define BOOST_LIB_C_VMS BOOST_PREDEF_MAKE_10_VVRR0PP00(__CRTL_VER) +#endif + +#if BOOST_LIB_C_VMS +# define BOOST_LIB_C_VMS_AVAILABLE +#endif + +#define BOOST_LIB_C_VMS_NAME "VMS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_VMS,BOOST_LIB_C_VMS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/c/zos.h b/src/thirdparty/boost_lib/boost/predef/library/c/zos.h new file mode 100644 index 000000000..4c6f0581d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/c/zos.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_C_ZOS_H +#define BOOST_PREDEF_LIBRARY_C_ZOS_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_C_ZOS`] + +z/OS libc Standard C library. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__LIBREL__`] [__predef_detection__]] + + [[`__LIBREL__`] [V.R.P]] + [[`__TARGET_LIB__`] [V.R.P]] + ] + */ + +#define BOOST_LIB_C_ZOS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__LIBREL__) +# undef BOOST_LIB_C_ZOS +# if !defined(BOOST_LIB_C_ZOS) && defined(__LIBREL__) +# define BOOST_LIB_C_ZOS BOOST_PREDEF_MAKE_0X_VRRPPPP(__LIBREL__) +# endif +# if !defined(BOOST_LIB_C_ZOS) && defined(__TARGET_LIB__) +# define BOOST_LIB_C_ZOS BOOST_PREDEF_MAKE_0X_VRRPPPP(__TARGET_LIB__) +# endif +# if !defined(BOOST_LIB_C_ZOS) +# define BOOST_LIB_C_ZOS BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LIB_C_ZOS +# define BOOST_LIB_C_ZOS_AVAILABLE +#endif + +#define BOOST_LIB_C_ZOS_NAME "z/OS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_ZOS,BOOST_LIB_C_ZOS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std.h b/src/thirdparty/boost_lib/boost/predef/library/std.h new file mode 100644 index 000000000..9ab0a863c --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std.h @@ -0,0 +1,23 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_PREDEF_LIBRARY_STD_H +#define BOOST_PREDEF_LIBRARY_STD_H + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/_prefix.h b/src/thirdparty/boost_lib/boost/predef/library/std/_prefix.h new file mode 100644 index 000000000..932b8557b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/_prefix.h @@ -0,0 +1,23 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_PREDEF_LIBRARY_STD__PREFIX_H +#define BOOST_PREDEF_LIBRARY_STD__PREFIX_H + +/* +We need to include an STD header to gives us the context +of which library we are using. The "smallest" code-wise header +seems to be . Boost uses but as far +as I can tell (RR) it's not a stand-alone header in most +implementations. Using also has the benefit of +being available in EC++, so we get a chance to make this work +for embedded users. And since it's not a header impacted by TR1 +there's no magic needed for inclusion in the face of the +Boost.TR1 library. +*/ +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/cxx.h b/src/thirdparty/boost_lib/boost/predef/library/std/cxx.h new file mode 100644 index 000000000..1d0cf5f2b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/cxx.h @@ -0,0 +1,47 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_CXX_H +#define BOOST_PREDEF_LIBRARY_STD_CXX_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_CXX`] + +[@http://libcxx.llvm.org/ libc++] C++ Standard Library. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_LIBCPP_VERSION`] [__predef_detection__]] + + [[`_LIBCPP_VERSION`] [V.0.P]] + ] + */ + +#define BOOST_LIB_STD_CXX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(_LIBCPP_VERSION) +# undef BOOST_LIB_STD_CXX +# define BOOST_LIB_STD_CXX BOOST_PREDEF_MAKE_10_VPPP(_LIBCPP_VERSION) +#endif + +#if BOOST_LIB_STD_CXX +# define BOOST_LIB_STD_CXX_AVAILABLE +#endif + +#define BOOST_LIB_STD_CXX_NAME "libc++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_CXX,BOOST_LIB_STD_CXX_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/dinkumware.h b/src/thirdparty/boost_lib/boost/predef/library/std/dinkumware.h new file mode 100644 index 000000000..394e866ea --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/dinkumware.h @@ -0,0 +1,53 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_DINKUMWARE_H +#define BOOST_PREDEF_LIBRARY_STD_DINKUMWARE_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_DINKUMWARE`] + +[@http://en.wikipedia.org/wiki/Dinkumware Dinkumware] Standard C++ Library. +If available version number as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_YVALS`, `__IBMCPP__`] [__predef_detection__]] + [[`_CPPLIB_VER`] [__predef_detection__]] + + [[`_CPPLIB_VER`] [V.R.0]] + ] + */ + +#define BOOST_LIB_STD_DINKUMWARE BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) +# undef BOOST_LIB_STD_DINKUMWARE +# if defined(_CPPLIB_VER) +# define BOOST_LIB_STD_DINKUMWARE BOOST_PREDEF_MAKE_10_VVRR(_CPPLIB_VER) +# else +# define BOOST_LIB_STD_DINKUMWARE BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LIB_STD_DINKUMWARE +# define BOOST_LIB_STD_DINKUMWARE_AVAILABLE +#endif + +#define BOOST_LIB_STD_DINKUMWARE_NAME "Dinkumware" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_DINKUMWARE,BOOST_LIB_STD_DINKUMWARE_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/libcomo.h b/src/thirdparty/boost_lib/boost/predef/library/std/libcomo.h new file mode 100644 index 000000000..41bbe6778 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/libcomo.h @@ -0,0 +1,48 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_LIBCOMO_H +#define BOOST_PREDEF_LIBRARY_STD_LIBCOMO_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_COMO`] + +[@http://www.comeaucomputing.com/libcomo/ Comeau Computing] Standard C++ Library. +Version number available as major. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__LIBCOMO__`] [__predef_detection__]] + + [[`__LIBCOMO_VERSION__`] [V.0.0]] + ] + */ + +#define BOOST_LIB_STD_COMO BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__LIBCOMO__) +# undef BOOST_LIB_STD_COMO +# define BOOST_LIB_STD_COMO BOOST_VERSION_NUMBER(__LIBCOMO_VERSION__,0,0) +#endif + +#if BOOST_LIB_STD_COMO +# define BOOST_LIB_STD_COMO_AVAILABLE +#endif + +#define BOOST_LIB_STD_COMO_NAME "Comeau Computing" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_COMO,BOOST_LIB_STD_COMO_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/modena.h b/src/thirdparty/boost_lib/boost/predef/library/std/modena.h new file mode 100644 index 000000000..fa7c061cf --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/modena.h @@ -0,0 +1,46 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_MODENA_H +#define BOOST_PREDEF_LIBRARY_STD_MODENA_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_MSIPL`] + +[@http://modena.us/ Modena Software Lib++] Standard C++ Library. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`MSIPL_COMPILE_H`] [__predef_detection__]] + [[`__MSIPL_COMPILE_H`] [__predef_detection__]] + ] + */ + +#define BOOST_LIB_STD_MSIPL BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(MSIPL_COMPILE_H) || defined(__MSIPL_COMPILE_H) +# undef BOOST_LIB_STD_MSIPL +# define BOOST_LIB_STD_MSIPL BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_LIB_STD_MSIPL +# define BOOST_LIB_STD_MSIPL_AVAILABLE +#endif + +#define BOOST_LIB_STD_MSIPL_NAME "Modena Software Lib++" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_MSIPL,BOOST_LIB_STD_MSIPL_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/msl.h b/src/thirdparty/boost_lib/boost/predef/library/std/msl.h new file mode 100644 index 000000000..16ddec690 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/msl.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_MSL_H +#define BOOST_PREDEF_LIBRARY_STD_MSL_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_MSL`] + +[@http://www.freescale.com/ Metrowerks] Standard C++ Library. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MSL_CPP__`] [__predef_detection__]] + [[`__MSL__`] [__predef_detection__]] + + [[`__MSL_CPP__`] [V.R.P]] + [[`__MSL__`] [V.R.P]] + ] + */ + +#define BOOST_LIB_STD_MSL BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__MSL_CPP__) || defined(__MSL__) +# undef BOOST_LIB_STD_MSL +# if defined(__MSL_CPP__) +# define BOOST_LIB_STD_MSL BOOST_PREDEF_MAKE_0X_VRPP(__MSL_CPP__) +# else +# define BOOST_LIB_STD_MSL BOOST_PREDEF_MAKE_0X_VRPP(__MSL__) +# endif +#endif + +#if BOOST_LIB_STD_MSL +# define BOOST_LIB_STD_MSL_AVAILABLE +#endif + +#define BOOST_LIB_STD_MSL_NAME "Metrowerks" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_MSL,BOOST_LIB_STD_MSL_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/roguewave.h b/src/thirdparty/boost_lib/boost/predef/library/std/roguewave.h new file mode 100644 index 000000000..38471d09a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/roguewave.h @@ -0,0 +1,57 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_ROGUEWAVE_H +#define BOOST_PREDEF_LIBRARY_STD_ROGUEWAVE_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_RW`] + +[@http://stdcxx.apache.org/ Roguewave] Standard C++ library. +If available version number as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__STD_RWCOMPILER_H__`] [__predef_detection__]] + [[`_RWSTD_VER`] [__predef_detection__]] + + [[`_RWSTD_VER`] [V.R.P]] + ] + */ + +#define BOOST_LIB_STD_RW BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) +# undef BOOST_LIB_STD_RW +# if defined(_RWSTD_VER) +# if _RWSTD_VER < 0x010000 +# define BOOST_LIB_STD_RW BOOST_PREDEF_MAKE_0X_VVRRP(_RWSTD_VER) +# else +# define BOOST_LIB_STD_RW BOOST_PREDEF_MAKE_0X_VVRRPP(_RWSTD_VER) +# endif +# else +# define BOOST_LIB_STD_RW BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LIB_STD_RW +# define BOOST_LIB_STD_RW_AVAILABLE +#endif + +#define BOOST_LIB_STD_RW_NAME "Roguewave" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_RW,BOOST_LIB_STD_RW_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/sgi.h b/src/thirdparty/boost_lib/boost/predef/library/std/sgi.h new file mode 100644 index 000000000..16f0db107 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/sgi.h @@ -0,0 +1,52 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_SGI_H +#define BOOST_PREDEF_LIBRARY_STD_SGI_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_SGI`] + +[@http://www.sgi.com/tech/stl/ SGI] Standard C++ library. +If available version number as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__STL_CONFIG_H`] [__predef_detection__]] + + [[`__SGI_STL`] [V.R.P]] + ] + */ + +#define BOOST_LIB_STD_SGI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__STL_CONFIG_H) +# undef BOOST_LIB_STD_SGI +# if defined(__SGI_STL) +# define BOOST_LIB_STD_SGI BOOST_PREDEF_MAKE_0X_VRP(__SGI_STL) +# else +# define BOOST_LIB_STD_SGI BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LIB_STD_SGI +# define BOOST_LIB_STD_SGI_AVAILABLE +#endif + +#define BOOST_LIB_STD_SGI_NAME "SGI" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_SGI,BOOST_LIB_STD_SGI_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/stdcpp3.h b/src/thirdparty/boost_lib/boost/predef/library/std/stdcpp3.h new file mode 100644 index 000000000..19ebc8683 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/stdcpp3.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_STDCPP3_H +#define BOOST_PREDEF_LIBRARY_STD_STDCPP3_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_GNU`] + +[@http://gcc.gnu.org/libstdc++/ GNU libstdc++] Standard C++ library. +Version number available as year (from 1970), month, and day. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__GLIBCXX__`] [__predef_detection__]] + [[`__GLIBCPP__`] [__predef_detection__]] + + [[`__GLIBCXX__`] [V.R.P]] + [[`__GLIBCPP__`] [V.R.P]] + ] + */ + +#define BOOST_LIB_STD_GNU BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__GLIBCPP__) || defined(__GLIBCXX__) +# undef BOOST_LIB_STD_GNU +# if defined(__GLIBCXX__) +# define BOOST_LIB_STD_GNU BOOST_PREDEF_MAKE_YYYYMMDD(__GLIBCXX__) +# else +# define BOOST_LIB_STD_GNU BOOST_PREDEF_MAKE_YYYYMMDD(__GLIBCPP__) +# endif +#endif + +#if BOOST_LIB_STD_GNU +# define BOOST_LIB_STD_GNU_AVAILABLE +#endif + +#define BOOST_LIB_STD_GNU_NAME "GNU" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_GNU,BOOST_LIB_STD_GNU_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/stlport.h b/src/thirdparty/boost_lib/boost/predef/library/std/stlport.h new file mode 100644 index 000000000..1b6cebb01 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/stlport.h @@ -0,0 +1,60 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_STLPORT_H +#define BOOST_PREDEF_LIBRARY_STD_STLPORT_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_STLPORT`] + +[@http://sourceforge.net/projects/stlport/ STLport Standard C++] library. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__SGI_STL_PORT`] [__predef_detection__]] + [[`_STLPORT_VERSION`] [__predef_detection__]] + + [[`_STLPORT_MAJOR`, `_STLPORT_MINOR`, `_STLPORT_PATCHLEVEL`] [V.R.P]] + [[`_STLPORT_VERSION`] [V.R.P]] + [[`__SGI_STL_PORT`] [V.R.P]] + ] + */ + +#define BOOST_LIB_STD_STLPORT BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +# undef BOOST_LIB_STD_STLPORT +# if !defined(BOOST_LIB_STD_STLPORT) && defined(_STLPORT_MAJOR) +# define BOOST_LIB_STD_STLPORT \ + BOOST_VERSION_NUMBER(_STLPORT_MAJOR,_STLPORT_MINOR,_STLPORT_PATCHLEVEL) +# endif +# if !defined(BOOST_LIB_STD_STLPORT) && defined(_STLPORT_VERSION) +# define BOOST_LIB_STD_STLPORT BOOST_PREDEF_MAKE_0X_VRP(_STLPORT_VERSION) +# endif +# if !defined(BOOST_LIB_STD_STLPORT) +# define BOOST_LIB_STD_STLPORT BOOST_PREDEF_MAKE_0X_VRP(__SGI_STL_PORT) +# endif +#endif + +#if BOOST_LIB_STD_STLPORT +# define BOOST_LIB_STD_STLPORT_AVAILABLE +#endif + +#define BOOST_LIB_STD_STLPORT_NAME "STLport" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_STLPORT,BOOST_LIB_STD_STLPORT_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/library/std/vacpp.h b/src/thirdparty/boost_lib/boost/predef/library/std/vacpp.h new file mode 100644 index 000000000..1c259c558 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/library/std/vacpp.h @@ -0,0 +1,45 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_LIBRARY_STD_VACPP_H +#define BOOST_PREDEF_LIBRARY_STD_VACPP_H + +#include + +#include +#include + +/*` +[heading `BOOST_LIB_STD_IBM`] + +[@http://www.ibm.com/software/awdtools/xlcpp/ IBM VACPP Standard C++] library. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__IBMCPP__`] [__predef_detection__]] + ] + */ + +#define BOOST_LIB_STD_IBM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__IBMCPP__) +# undef BOOST_LIB_STD_IBM +# define BOOST_LIB_STD_IBM BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_LIB_STD_IBM +# define BOOST_LIB_STD_IBM_AVAILABLE +#endif + +#define BOOST_LIB_STD_IBM_NAME "IBM VACPP" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_IBM,BOOST_LIB_STD_IBM_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/make.h b/src/thirdparty/boost_lib/boost/predef/make.h new file mode 100644 index 000000000..d327906f2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/make.h @@ -0,0 +1,87 @@ +/* +Copyright Rene Rivera 2008-2013 +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 + +#ifndef BOOST_PREDEF_MAKE_H +#define BOOST_PREDEF_MAKE_H + +/* +Shorthands for the common version number formats used by vendors... +*/ + +/*` +[heading `BOOST_PREDEF_MAKE_..` macros] + +These set of macros decompose common vendor version number +macros which are composed version, revision, and patch digits. +The naming convention indicates: + +* The base of the specified version number. "`BOOST_PREDEF_MAKE_0X`" for + hexadecimal digits, and "`BOOST_PREDEF_MAKE_10`" for decimal digits. +* The format of the vendor version number. Where "`V`" indicates the version digits, + "`R`" indicates the revision digits, "`P`" indicates the patch digits, and "`0`" + indicates an ignored digit. + +Macros are: +*/ +/*` `BOOST_PREDEF_MAKE_0X_VRP(V)` */ +#define BOOST_PREDEF_MAKE_0X_VRP(V) BOOST_VERSION_NUMBER((V&0xF00)>>8,(V&0xF0)>>4,(V&0xF)) +/*` `BOOST_PREDEF_MAKE_0X_VVRP(V)` */ +#define BOOST_PREDEF_MAKE_0X_VVRP(V) BOOST_VERSION_NUMBER((V&0xFF00)>>8,(V&0xF0)>>4,(V&0xF)) +/*` `BOOST_PREDEF_MAKE_0X_VRPP(V)` */ +#define BOOST_PREDEF_MAKE_0X_VRPP(V) BOOST_VERSION_NUMBER((V&0xF000)>>12,(V&0xF00)>>8,(V&0xFF)) +/*` `BOOST_PREDEF_MAKE_0X_VVRR(V)` */ +#define BOOST_PREDEF_MAKE_0X_VVRR(V) BOOST_VERSION_NUMBER((V&0xFF00)>>8,(V&0xFF),0) +/*` `BOOST_PREDEF_MAKE_0X_VRRPPPP(V)` */ +#define BOOST_PREDEF_MAKE_0X_VRRPPPP(V) BOOST_VERSION_NUMBER((V&0xF000000)>>24,(V&0xFF0000)>>16,(V&0xFFFF)) +/*` `BOOST_PREDEF_MAKE_0X_VVRRP(V)` */ +#define BOOST_PREDEF_MAKE_0X_VVRRP(V) BOOST_VERSION_NUMBER((V&0xFF000)>>12,(V&0xFF0)>>4,(V&0xF)) +/*` `BOOST_PREDEF_MAKE_0X_VRRPP000(V)` */ +#define BOOST_PREDEF_MAKE_0X_VRRPP000(V) BOOST_VERSION_NUMBER((V&0xF0000000)>>28,(V&0xFF00000)>>20,(V&0xFF000)>>12) +/*` `BOOST_PREDEF_MAKE_10_VPPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VPPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,0,(V)%1000) +/*` `BOOST_PREDEF_MAKE_10_VRP(V)` */ +#define BOOST_PREDEF_MAKE_10_VRP(V) BOOST_VERSION_NUMBER(((V)/100)%10,((V)/10)%10,(V)%10) +/*` `BOOST_PREDEF_MAKE_10_VRP000(V)` */ +#define BOOST_PREDEF_MAKE_10_VRP000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/10000)%10,((V)/1000)%10) +/*` `BOOST_PREDEF_MAKE_10_VRPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VRPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,((V)/100)%10,(V)%100) +/*` `BOOST_PREDEF_MAKE_10_VRR(V)` */ +#define BOOST_PREDEF_MAKE_10_VRR(V) BOOST_VERSION_NUMBER(((V)/100)%10,(V)%100,0) +/*` `BOOST_PREDEF_MAKE_10_VRRPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%10,((V)/100)%100,(V)%100) +/*` `BOOST_PREDEF_MAKE_10_VRR000(V)` */ +#define BOOST_PREDEF_MAKE_10_VRR000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/1000)%100,0) +/*` `BOOST_PREDEF_MAKE_10_VV00(V)` */ +#define BOOST_PREDEF_MAKE_10_VV00(V) BOOST_VERSION_NUMBER(((V)/100)%100,0,0) +/*` `BOOST_PREDEF_MAKE_10_VVRR(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRR(V) BOOST_VERSION_NUMBER(((V)/100)%100,(V)%100,0) +/*` `BOOST_PREDEF_MAKE_10_VVRRPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%100,((V)/100)%100,(V)%100) +/*` `BOOST_PREDEF_MAKE_10_VVRR0PP00(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRR0PP00(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,((V)/100)%100) +/*` `BOOST_PREDEF_MAKE_10_VVRR0PPPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRR0PPPP(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,(V)%10000) +/*` `BOOST_PREDEF_MAKE_10_VVRR00PP00(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRR00PP00(V) BOOST_VERSION_NUMBER(((V)/100000000)%100,((V)/1000000)%100,((V)/100)%100) +/*` +[heading `BOOST_PREDEF_MAKE_*..` date macros] + +Date decomposition macros return a date in the relative to the 1970 +Epoch date. If the month is not available, January 1st is used as the month and day. +If the day is not available, but the month is, the 1st of the month is used as the day. +*/ +/*` `BOOST_PREDEF_MAKE_DATE(Y,M,D)` */ +#define BOOST_PREDEF_MAKE_DATE(Y,M,D) BOOST_VERSION_NUMBER((Y)%10000-1970,(M)%100,(D)%100) +/*` `BOOST_PREDEF_MAKE_YYYYMMDD(V)` */ +#define BOOST_PREDEF_MAKE_YYYYMMDD(V) BOOST_PREDEF_MAKE_DATE(((V)/10000)%10000,((V)/100)%100,(V)%100) +/*` `BOOST_PREDEF_MAKE_YYYY(V)` */ +#define BOOST_PREDEF_MAKE_YYYY(V) BOOST_PREDEF_MAKE_DATE(V,1,1) +/*` `BOOST_PREDEF_MAKE_YYYYMM(V)` */ +#define BOOST_PREDEF_MAKE_YYYYMM(V) BOOST_PREDEF_MAKE_DATE((V)/100,(V),1) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os.h b/src/thirdparty/boost_lib/boost/predef/os.h new file mode 100644 index 000000000..628eb4f44 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os.h @@ -0,0 +1,30 @@ +/* +Copyright Rene Rivera 2008-2012 +Copyright Franz Detro 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_H +#define BOOST_PREDEF_OS_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/aix.h b/src/thirdparty/boost_lib/boost/predef/os/aix.h new file mode 100644 index 000000000..07523c8de --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/aix.h @@ -0,0 +1,67 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_AIX_H +#define BOOST_PREDEF_OS_AIX_H + +#include +#include + +/*` +[heading `BOOST_OS_AIX`] + +[@http://en.wikipedia.org/wiki/AIX_operating_system IBM AIX] operating system. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_AIX`] [__predef_detection__]] + [[`__TOS_AIX__`] [__predef_detection__]] + + [[`_AIX43`] [4.3.0]] + [[`_AIX41`] [4.1.0]] + [[`_AIX32`] [3.2.0]] + [[`_AIX3`] [3.0.0]] + ] + */ + +#define BOOST_OS_AIX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(_AIX) || defined(__TOS_AIX__) \ + ) +# undef BOOST_OS_AIX +# if !defined(BOOST_OS_AIX) && defined(_AIX43) +# define BOOST_OS_AIX BOOST_VERSION_NUMBER(4,3,0) +# endif +# if !defined(BOOST_OS_AIX) && defined(_AIX41) +# define BOOST_OS_AIX BOOST_VERSION_NUMBER(4,1,0) +# endif +# if !defined(BOOST_OS_AIX) && defined(_AIX32) +# define BOOST_OS_AIX BOOST_VERSION_NUMBER(3,2,0) +# endif +# if !defined(BOOST_OS_AIX) && defined(_AIX3) +# define BOOST_OS_AIX BOOST_VERSION_NUMBER(3,0,0) +# endif +# if !defined(BOOST_OS_AIX) +# define BOOST_OS_AIX BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_AIX +# define BOOST_OS_AIX_AVAILABLE +# include +#endif + +#define BOOST_OS_AIX_NAME "IBM AIX" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_AIX,BOOST_OS_AIX_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/amigaos.h b/src/thirdparty/boost_lib/boost/predef/os/amigaos.h new file mode 100644 index 000000000..fae2408bd --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/amigaos.h @@ -0,0 +1,47 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_AMIGAOS_H +#define BOOST_PREDEF_OS_AMIGAOS_H + +#include +#include + +/*` +[heading `BOOST_OS_AMIGAOS`] + +[@http://en.wikipedia.org/wiki/AmigaOS AmigaOS] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`AMIGA`] [__predef_detection__]] + [[`__amigaos__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_AMIGAOS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(AMIGA) || defined(__amigaos__) \ + ) +# undef BOOST_OS_AMIGAOS +# define BOOST_OS_AMIGAOS BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_AMIGAOS +# define BOOST_OS_AMIGAOS_AVAILABLE +# include +#endif + +#define BOOST_OS_AMIGAOS_NAME "AmigaOS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_AMIGAOS,BOOST_OS_AMIGAOS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/android.h b/src/thirdparty/boost_lib/boost/predef/os/android.h new file mode 100644 index 000000000..0de5870d4 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/android.h @@ -0,0 +1,46 @@ +/* +Copyright Rene Rivera 2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_ADROID_H +#define BOOST_PREDEF_OS_ADROID_H + +#include +#include + +/*` +[heading `BOOST_OS_ANDROID`] + +[@http://en.wikipedia.org/wiki/Android_%28operating_system%29 Android] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__ANDROID__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_ANDROID BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__ANDROID__) \ + ) +# undef BOOST_OS_ANDROID +# define BOOST_OS_ANDROID BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_ANDROID +# define BOOST_OS_ANDROID_AVAILABLE +# include +#endif + +#define BOOST_OS_ANDROID_NAME "Android" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_ANDROID,BOOST_OS_ANDROID_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/beos.h b/src/thirdparty/boost_lib/boost/predef/os/beos.h new file mode 100644 index 000000000..7a92b944a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/beos.h @@ -0,0 +1,46 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BEOS_H +#define BOOST_PREDEF_OS_BEOS_H + +#include +#include + +/*` +[heading `BOOST_OS_BEOS`] + +[@http://en.wikipedia.org/wiki/BeOS BeOS] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__BEOS__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_BEOS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__BEOS__) \ + ) +# undef BOOST_OS_BEOS +# define BOOST_OS_BEOS BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_BEOS +# define BOOST_OS_BEOS_AVAILABLE +# include +#endif + +#define BOOST_OS_BEOS_NAME "BeOS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BEOS,BOOST_OS_BEOS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/bsd.h b/src/thirdparty/boost_lib/boost/predef/os/bsd.h new file mode 100644 index 000000000..f370f56ba --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/bsd.h @@ -0,0 +1,95 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BSD_H +#define BOOST_PREDEF_OS_BSD_H + +/* Special case: OSX will define BSD predefs if the sys/param.h + * header is included. We can guard against that, but only if we + * detect OSX first. Hence we will force include OSX detection + * before doing any BSD detection. + */ +#include + +#include +#include + +/*` +[heading `BOOST_OS_BSD`] + +[@http://en.wikipedia.org/wiki/Berkeley_Software_Distribution BSD] operating system. + +BSD has various branch operating systems possible and each detected +individually. This detects the following variations and sets a specific +version number macro to match: + +* `BOOST_OS_BSD_DRAGONFLY` [@http://en.wikipedia.org/wiki/DragonFly_BSD DragonFly BSD] +* `BOOST_OS_BSD_FREE` [@http://en.wikipedia.org/wiki/Freebsd FreeBSD] +* `BOOST_OS_BSD_BSDI` [@http://en.wikipedia.org/wiki/BSD/OS BSDi BSD/OS] +* `BOOST_OS_BSD_NET` [@http://en.wikipedia.org/wiki/Netbsd NetBSD] +* `BOOST_OS_BSD_OPEN` [@http://en.wikipedia.org/wiki/Openbsd OpenBSD] + +[note The general `BOOST_OS_BSD` is set in all cases to indicate some form +of BSD. If the above variants is detected the corresponding macro is also set.] + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`BSD`] [__predef_detection__]] + [[`_SYSTYPE_BSD`] [__predef_detection__]] + + [[`BSD4_2`] [4.2.0]] + [[`BSD4_3`] [4.3.0]] + [[`BSD4_4`] [4.4.0]] + [[`BSD`] [V.R.0]] + ] + */ + +#include +#include +#include +#include +#include + +#ifndef BOOST_OS_BSD +#define BOOST_OS_BSD BOOST_VERSION_NUMBER_NOT_AVAILABLE +#endif + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(BSD) || \ + defined(_SYSTYPE_BSD) \ + ) +# undef BOOST_OS_BSD +# include +# if !defined(BOOST_OS_BSD) && defined(BSD4_4) +# define BOOST_OS_BSD BOOST_VERSION_NUMBER(4,4,0) +# endif +# if !defined(BOOST_OS_BSD) && defined(BSD4_3) +# define BOOST_OS_BSD BOOST_VERSION_NUMBER(4,3,0) +# endif +# if !defined(BOOST_OS_BSD) && defined(BSD4_2) +# define BOOST_OS_BSD BOOST_VERSION_NUMBER(4,2,0) +# endif +# if !defined(BOOST_OS_BSD) && defined(BSD) +# define BOOST_OS_BSD BOOST_PREDEF_MAKE_10_VVRR(BSD) +# endif +# if !defined(BOOST_OS_BSD) +# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_BSD +# define BOOST_OS_BSD_AVAILABLE +# include +#endif + +#define BOOST_OS_BSD_NAME "BSD" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD,BOOST_OS_BSD_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/bsd/bsdi.h b/src/thirdparty/boost_lib/boost/predef/os/bsd/bsdi.h new file mode 100644 index 000000000..cb57e1bcd --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/bsd/bsdi.h @@ -0,0 +1,48 @@ +/* +Copyright Rene Rivera 2012-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BSD_BSDI_H +#define BOOST_PREDEF_OS_BSD_BSDI_H + +#include + +/*` +[heading `BOOST_OS_BSD_BSDI`] + +[@http://en.wikipedia.org/wiki/BSD/OS BSDi BSD/OS] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__bsdi__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_BSD_BSDI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__bsdi__) \ + ) +# ifndef BOOST_OS_BSD_AVAILABLE +# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE +# define BOOST_OS_BSD_AVAILABLE +# endif +# undef BOOST_OS_BSD_BSDI +# define BOOST_OS_BSD_BSDI BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_BSD_BSDI +# define BOOST_OS_BSD_BSDI_AVAILABLE +# include +#endif + +#define BOOST_OS_BSD_BSDI_NAME "BSDi BSD/OS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_BSDI,BOOST_OS_BSD_BSDI_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/bsd/dragonfly.h b/src/thirdparty/boost_lib/boost/predef/os/bsd/dragonfly.h new file mode 100644 index 000000000..202f8a1de --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/bsd/dragonfly.h @@ -0,0 +1,50 @@ +/* +Copyright Rene Rivera 2012-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BSD_DRAGONFLY_H +#define BOOST_PREDEF_OS_BSD_DRAGONFLY_H + +#include + +/*` +[heading `BOOST_OS_BSD_DRAGONFLY`] + +[@http://en.wikipedia.org/wiki/DragonFly_BSD DragonFly BSD] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__DragonFly__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_BSD_DRAGONFLY BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__DragonFly__) \ + ) +# ifndef BOOST_OS_BSD_AVAILABLE +# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE +# define BOOST_OS_BSD_AVAILABLE +# endif +# undef BOOST_OS_BSD_DRAGONFLY +# if defined(__DragonFly__) +# define BOOST_OS_DRAGONFLY_BSD BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_BSD_DRAGONFLY +# define BOOST_OS_BSD_DRAGONFLY_AVAILABLE +# include +#endif + +#define BOOST_OS_BSD_DRAGONFLY_NAME "DragonFly BSD" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_DRAGONFLY,BOOST_OS_BSD_DRAGONFLY_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/bsd/free.h b/src/thirdparty/boost_lib/boost/predef/os/bsd/free.h new file mode 100644 index 000000000..404e8ed83 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/bsd/free.h @@ -0,0 +1,60 @@ +/* +Copyright Rene Rivera 2012-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BSD_FREE_H +#define BOOST_PREDEF_OS_BSD_FREE_H + +#include + +/*` +[heading `BOOST_OS_BSD_FREE`] + +[@http://en.wikipedia.org/wiki/Freebsd FreeBSD] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__FreeBSD__`] [__predef_detection__]] + + [[`__FreeBSD_version`] [V.R.P]] + ] + */ + +#define BOOST_OS_BSD_FREE BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__FreeBSD__) \ + ) +# ifndef BOOST_OS_BSD_AVAILABLE +# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE +# define BOOST_OS_BSD_AVAILABLE +# endif +# undef BOOST_OS_BSD_FREE +# if defined(__FreeBSD_version) +# if __FreeBSD_version < 500000 +# define BOOST_OS_BSD_FREE \ + BOOST_PREDEF_MAKE_10_VRP000(__FreeBSD_version) +# else +# define BOOST_OS_BSD_FREE \ + BOOST_PREDEF_MAKE_10_VRR000(__FreeBSD_version) +# endif +# else +# define BOOST_OS_BSD_FREE BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_BSD_FREE +# define BOOST_OS_BSD_FREE_AVAILABLE +# include +#endif + +#define BOOST_OS_BSD_FREE_NAME "Free BSD" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_FREE,BOOST_OS_BSD_FREE_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/bsd/net.h b/src/thirdparty/boost_lib/boost/predef/os/bsd/net.h new file mode 100644 index 000000000..dcc4131b8 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/bsd/net.h @@ -0,0 +1,84 @@ +/* +Copyright Rene Rivera 2012-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BSD_NET_H +#define BOOST_PREDEF_OS_BSD_NET_H + +#include + +/*` +[heading `BOOST_OS_BSD_NET`] + +[@http://en.wikipedia.org/wiki/Netbsd NetBSD] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__NETBSD__`] [__predef_detection__]] + [[`__NetBSD__`] [__predef_detection__]] + + [[`__NETBSD_version`] [V.R.P]] + [[`NetBSD0_8`] [0.8.0]] + [[`NetBSD0_9`] [0.9.0]] + [[`NetBSD1_0`] [1.0.0]] + [[`__NetBSD_Version`] [V.R.P]] + ] + */ + +#define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__NETBSD__) || defined(__NetBSD__) \ + ) +# ifndef BOOST_OS_BSD_AVAILABLE +# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE +# define BOOST_OS_BSD_AVAILABLE +# endif +# undef BOOST_OS_BSD_NET +# if defined(__NETBSD__) +# if defined(__NETBSD_version) +# if __NETBSD_version < 500000 +# define BOOST_OS_BSD_NET \ + BOOST_PREDEF_MAKE_10_VRP000(__NETBSD_version) +# else +# define BOOST_OS_BSD_NET \ + BOOST_PREDEF_MAKE_10_VRR000(__NETBSD_version) +# endif +# else +# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_AVAILABLE +# endif +# elif defined(__NetBSD__) +# if !defined(BOOST_OS_BSD_NET) && defined(NetBSD0_8) +# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER(0,8,0) +# endif +# if !defined(BOOST_OS_BSD_NET) && defined(NetBSD0_9) +# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER(0,9,0) +# endif +# if !defined(BOOST_OS_BSD_NET) && defined(NetBSD1_0) +# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER(1,0,0) +# endif +# if !defined(BOOST_OS_BSD_NET) && defined(__NetBSD_Version) +# define BOOST_OS_BSD_NET \ + BOOST_PREDEF_MAKE_10_VVRR00PP00(__NetBSD_Version) +# endif +# if !defined(BOOST_OS_BSD_NET) +# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_AVAILABLE +# endif +# endif +#endif + +#if BOOST_OS_BSD_NET +# define BOOST_OS_BSD_NET_AVAILABLE +# include +#endif + +#define BOOST_OS_BSD_NET_NAME "DragonFly BSD" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_NET,BOOST_OS_BSD_NET_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/bsd/open.h b/src/thirdparty/boost_lib/boost/predef/os/bsd/open.h new file mode 100644 index 000000000..e81ebc643 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/bsd/open.h @@ -0,0 +1,171 @@ +/* +Copyright Rene Rivera 2012-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_BSD_OPEN_H +#define BOOST_PREDEF_OS_BSD_OPEN_H + +#include + +/*` +[heading `BOOST_OS_BSD_OPEN`] + +[@http://en.wikipedia.org/wiki/Openbsd OpenBSD] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__OpenBSD__`] [__predef_detection__]] + + [[`OpenBSD2_0`] [2.0.0]] + [[`OpenBSD2_1`] [2.1.0]] + [[`OpenBSD2_2`] [2.2.0]] + [[`OpenBSD2_3`] [2.3.0]] + [[`OpenBSD2_4`] [2.4.0]] + [[`OpenBSD2_5`] [2.5.0]] + [[`OpenBSD2_6`] [2.6.0]] + [[`OpenBSD2_7`] [2.7.0]] + [[`OpenBSD2_8`] [2.8.0]] + [[`OpenBSD2_9`] [2.9.0]] + [[`OpenBSD3_0`] [3.0.0]] + [[`OpenBSD3_1`] [3.1.0]] + [[`OpenBSD3_2`] [3.2.0]] + [[`OpenBSD3_3`] [3.3.0]] + [[`OpenBSD3_4`] [3.4.0]] + [[`OpenBSD3_5`] [3.5.0]] + [[`OpenBSD3_6`] [3.6.0]] + [[`OpenBSD3_7`] [3.7.0]] + [[`OpenBSD3_8`] [3.8.0]] + [[`OpenBSD3_9`] [3.9.0]] + [[`OpenBSD4_0`] [4.0.0]] + [[`OpenBSD4_1`] [4.1.0]] + [[`OpenBSD4_2`] [4.2.0]] + [[`OpenBSD4_3`] [4.3.0]] + [[`OpenBSD4_4`] [4.4.0]] + [[`OpenBSD4_5`] [4.5.0]] + [[`OpenBSD4_6`] [4.6.0]] + [[`OpenBSD4_7`] [4.7.0]] + [[`OpenBSD4_8`] [4.8.0]] + [[`OpenBSD4_9`] [4.9.0]] + ] + */ + +#define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__OpenBSD__) \ + ) +# ifndef BOOST_OS_BSD_AVAILABLE +# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE +# define BOOST_OS_BSD_AVAILABLE +# endif +# undef BOOST_OS_BSD_OPEN +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_0) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,0,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_1) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,1,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_2) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,2,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_3) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,3,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_4) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,4,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_5) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,5,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_6) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,6,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_7) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,7,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_8) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,8,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_9) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,9,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_0) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,0,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_1) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,1,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_2) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,2,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_3) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,3,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_4) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,4,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_5) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,5,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_6) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,6,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_7) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,7,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_8) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,8,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_9) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,9,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_0) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_1) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,1,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_2) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,2,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_3) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,3,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_4) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,4,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_5) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,5,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_6) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,6,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_7) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,7,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_8) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,8,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_9) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,9,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_BSD_OPEN +# define BOOST_OS_BSD_OPEN_AVAILABLE +# include +#endif + +#define BOOST_OS_BSD_OPEN_NAME "OpenBSD" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_OPEN,BOOST_OS_BSD_OPEN_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/cygwin.h b/src/thirdparty/boost_lib/boost/predef/os/cygwin.h new file mode 100644 index 000000000..04ee3995e --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/cygwin.h @@ -0,0 +1,46 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_CYGWIN_H +#define BOOST_PREDEF_OS_CYGWIN_H + +#include +#include + +/*` +[heading `BOOST_OS_CYGWIN`] + +[@http://en.wikipedia.org/wiki/Cygwin Cygwin] evironment. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__CYGWIN__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_CYGWIN BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__CYGWIN__) \ + ) +# undef BOOST_OS_CYGWIN +# define BOOST_OS_CGYWIN BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_CYGWIN +# define BOOST_OS_CYGWIN_AVAILABLE +# include +#endif + +#define BOOST_OS_CYGWIN_NAME "Cygwin" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_CYGWIN,BOOST_OS_CYGWIN_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/hpux.h b/src/thirdparty/boost_lib/boost/predef/os/hpux.h new file mode 100644 index 000000000..946196f4a --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/hpux.h @@ -0,0 +1,48 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_HPUX_H +#define BOOST_PREDEF_OS_HPUX_H + +#include +#include + +/*` +[heading `BOOST_OS_HPUX`] + +[@http://en.wikipedia.org/wiki/HP-UX HP-UX] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`hpux`] [__predef_detection__]] + [[`_hpux`] [__predef_detection__]] + [[`__hpux`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_HPUX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(hpux) || defined(_hpux) || defined(__hpux) \ + ) +# undef BOOST_OS_HPUX +# define BOOST_OS_HPUX BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_HPUX +# define BOOST_OS_HPUX_AVAILABLE +# include +#endif + +#define BOOST_OS_HPUX_NAME "HP-UX" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_HPUX,BOOST_OS_HPUX_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/ios.h b/src/thirdparty/boost_lib/boost/predef/os/ios.h new file mode 100644 index 000000000..b83a9db53 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/ios.h @@ -0,0 +1,51 @@ +/* +Copyright Franz Detro 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_IOS_H +#define BOOST_PREDEF_OS_IOS_H + +#include +#include + +/*` +[heading `BOOST_OS_IOS`] + +[@http://en.wikipedia.org/wiki/iOS iOS] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__APPLE__`] [__predef_detection__]] + [[`__MACH__`] [__predef_detection__]] + [[`__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__`] [__predef_detection__]] + + [[`__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__`] [__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000]] + ] + */ + +#define BOOST_OS_IOS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__APPLE__) && defined(__MACH__) && \ + defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) \ + ) +# undef BOOST_OS_IOS +# define BOOST_OS_IOS (__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000) +#endif + +#if BOOST_OS_IOS +# define BOOST_OS_IOS_AVAILABLE +# include +#endif + +#define BOOST_OS_IOS_NAME "iOS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_IOS,BOOST_OS_IOS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/irix.h b/src/thirdparty/boost_lib/boost/predef/os/irix.h new file mode 100644 index 000000000..a9e63b855 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/irix.h @@ -0,0 +1,47 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_IRIX_H +#define BOOST_PREDEF_OS_IRIX_H + +#include +#include + +/*` +[heading `BOOST_OS_IRIX`] + +[@http://en.wikipedia.org/wiki/Irix IRIX] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`sgi`] [__predef_detection__]] + [[`__sgi`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_IRIX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(sgi) || defined(__sgi) \ + ) +# undef BOOST_OS_IRIX +# define BOOST_OS_IRIX BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_IRIX +# define BOOST_OS_IRIX_AVAILABLE +# include +#endif + +#define BOOST_OS_IRIX_NAME "IRIX" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_IRIX,BOOST_OS_IRIX_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/linux.h b/src/thirdparty/boost_lib/boost/predef/os/linux.h new file mode 100644 index 000000000..b436e3fd4 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/linux.h @@ -0,0 +1,47 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_LINUX_H +#define BOOST_PREDEF_OS_LINUX_H + +#include +#include + +/*` +[heading `BOOST_OS_LINUX`] + +[@http://en.wikipedia.org/wiki/Linux Linux] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`linux`] [__predef_detection__]] + [[`__linux`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_LINUX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(linux) || defined(__linux) \ + ) +# undef BOOST_OS_LINUX +# define BOOST_OS_LINUX BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_LINUX +# define BOOST_OS_LINUX_AVAILABLE +# include +#endif + +#define BOOST_OS_LINUX_NAME "Linux" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_LINUX,BOOST_OS_LINUX_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/macos.h b/src/thirdparty/boost_lib/boost/predef/os/macos.h new file mode 100644 index 000000000..cdcf2cb2b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/macos.h @@ -0,0 +1,66 @@ +/* +Copyright Rene Rivera 2008-2013 +Copyright Franz Detro 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_MACOS_H +#define BOOST_PREDEF_OS_MACOS_H + +/* Special case: iOS will define the same predefs as MacOS, and additionally + '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__'. We can guard against that, + but only if we detect iOS first. Hence we will force include iOS detection + * before doing any MacOS detection. + */ +#include + +#include +#include + +/*` +[heading `BOOST_OS_MACOS`] + +[@http://en.wikipedia.org/wiki/Mac_OS Mac OS] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`macintosh`] [__predef_detection__]] + [[`Macintosh`] [__predef_detection__]] + [[`__APPLE__`] [__predef_detection__]] + [[`__MACH__`] [__predef_detection__]] + + [[`__APPLE__`, `__MACH__`] [10.0.0]] + [[ /otherwise/ ] [9.0.0]] + ] + */ + +#define BOOST_OS_MACOS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(macintosh) || defined(Macintosh) || \ + (defined(__APPLE__) && defined(__MACH__)) \ + ) +# undef BOOST_OS_MACOS +# if !defined(BOOST_OS_MACOS) && defined(__APPLE__) && defined(__MACH__) +# define BOOST_OS_MACOS BOOST_VERSION_NUMBER(10,0,0) +# endif +# if !defined(BOOST_OS_MACOS) +# define BOOST_OS_MACOS BOOST_VERSION_NUMBER(9,0,0) +# endif +#endif + +#if BOOST_OS_MACOS +# define BOOST_OS_MACOS_AVAILABLE +# include +#endif + +#define BOOST_OS_MACOS_NAME "Mac OS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_MACOS,BOOST_OS_MACOS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/os400.h b/src/thirdparty/boost_lib/boost/predef/os/os400.h new file mode 100644 index 000000000..f7aacf533 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/os400.h @@ -0,0 +1,46 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_OS400_H +#define BOOST_PREDEF_OS_OS400_H + +#include +#include + +/*` +[heading `BOOST_OS_OS400`] + +[@http://en.wikipedia.org/wiki/IBM_i IBM OS/400] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__OS400__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_OS400 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__OS400__) \ + ) +# undef BOOST_OS_OS400 +# define BOOST_OS_OS400 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_OS400 +# define BOOST_OS_OS400_AVAILABLE +# include +#endif + +#define BOOST_OS_OS400_NAME "IBM OS/400" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_OS400,BOOST_OS_OS400_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/qnxnto.h b/src/thirdparty/boost_lib/boost/predef/os/qnxnto.h new file mode 100644 index 000000000..dff536f2d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/qnxnto.h @@ -0,0 +1,60 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_QNXNTO_H +#define BOOST_PREDEF_OS_QNXNTO_H + +#include +#include + +/*` +[heading `BOOST_OS_QNX`] + +[@http://en.wikipedia.org/wiki/QNX QNX] operating system. +Version number available as major, and minor if possible. And +version 4 is specifically detected. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__QNX__`] [__predef_detection__]] + [[`__QNXNTO__`] [__predef_detection__]] + + [[`_NTO_VERSION`] [V.R.0]] + [[`__QNX__`] [4.0.0]] + ] + */ + +#define BOOST_OS_QNX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(__QNX__) || defined(__QNXNTO__) \ + ) +# undef BOOST_OS_QNX +# if !defined(BOOST_OS_QNX) && defined(_NTO_VERSION) +# define BOOST_OS_QNX BOOST_PREDEF_MAKE_10_VVRR(_NTO_VERSION) +# endif +# if !defined(BOOST_OS_QNX) && defined(__QNX__) +# define BOOST_OS_QNX BOOST_VERSION_NUMBER(4,0,0) +# endif +# if !defined(BOOST_OS_QNX) +# define BOOST_OS_QNX BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_QNX +# define BOOST_OS_QNX_AVAILABLE +# include +#endif + +#define BOOST_OS_QNX_NAME "QNX" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_QNX,BOOST_OS_QNX_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/solaris.h b/src/thirdparty/boost_lib/boost/predef/os/solaris.h new file mode 100644 index 000000000..4d47dfec1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/solaris.h @@ -0,0 +1,47 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_SOLARIS_H +#define BOOST_PREDEF_OS_SOLARIS_H + +#include +#include + +/*` +[heading `BOOST_OS_SOLARIS`] + +[@http://en.wikipedia.org/wiki/Solaris_Operating_Environment Solaris] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`sun`] [__predef_detection__]] + [[`__sun`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_SOLARIS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(sun) || defined(__sun) \ + ) +# undef BOOST_OS_SOLARIS +# define BOOST_OS_SOLARIS BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_SOLARIS +# define BOOST_OS_SOLARIS_AVAILABLE +# include +#endif + +#define BOOST_OS_SOLARIS_NAME "Solaris" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_SOLARIS,BOOST_OS_SOLARIS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/unix.h b/src/thirdparty/boost_lib/boost/predef/os/unix.h new file mode 100644 index 000000000..3636dda51 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/unix.h @@ -0,0 +1,76 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_UNIX_H +#define BOOST_PREDEF_OS_UNIX_H + +#include +#include + +/*` +[heading `BOOST_OS_UNIX`] + +[@http://en.wikipedia.org/wiki/Unix Unix Environment] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`unix`] [__predef_detection__]] + [[`__unix`] [__predef_detection__]] + [[`_XOPEN_SOURCE`] [__predef_detection__]] + [[`_POSIX_SOURCE`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_UNIX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(unix) || defined(__unix) || \ + defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE) +# undef BOOST_OS_UNIX +# define BOOST_OS_UNIX BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_UNIX +# define BOOST_OS_UNIX_AVAILABLE +#endif + +#define BOOST_OS_UNIX_NAME "Unix Environment" + +/*` +[heading `BOOST_OS_SVR4`] + +[@http://en.wikipedia.org/wiki/UNIX_System_V SVR4 Environment] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__sysv__`] [__predef_detection__]] + [[`__SVR4`] [__predef_detection__]] + [[`__svr4__`] [__predef_detection__]] + [[`_SYSTYPE_SVR4`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_SVR4 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__sysv__) || defined(__SVR4) || \ + defined(__svr4__) || defined(_SYSTYPE_SVR4) +# undef BOOST_OS_SVR4 +# define BOOST_OS_SVR4 BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_SVR4 +# define BOOST_OS_SVR4_AVAILABLE +#endif + +#define BOOST_OS_SVR4_NAME "SVR4 Environment" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_UNIX,BOOST_OS_UNIX_NAME) +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_SVR4,BOOST_OS_SVR4_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/vms.h b/src/thirdparty/boost_lib/boost/predef/os/vms.h new file mode 100644 index 000000000..3d34f63dd --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/vms.h @@ -0,0 +1,53 @@ +/* +Copyright Rene Rivera 2011-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_VMS_H +#define BOOST_PREDEF_OS_VMS_H + +#include +#include + +/*` +[heading `BOOST_OS_VMS`] + +[@http://en.wikipedia.org/wiki/Vms VMS] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`VMS`] [__predef_detection__]] + [[`__VMS`] [__predef_detection__]] + + [[`__VMS_VER`] [V.R.P]] + ] + */ + +#define BOOST_OS_VMS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(VMS) || defined(__VMS) \ + ) +# undef BOOST_OS_VMS +# if defined(__VMS_VER) +# define BOOST_OS_VMS BOOST_PREDEF_MAKE_10_VVRR00PP00(__VMS_VER) +# else +# define BOOST_OS_VMS BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_OS_VMS +# define BOOST_OS_VMS_AVAILABLE +# include +#endif + +#define BOOST_OS_VMS_NAME "VMS" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_VMS,BOOST_OS_VMS_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/os/windows.h b/src/thirdparty/boost_lib/boost/predef/os/windows.h new file mode 100644 index 000000000..9072539ae --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/os/windows.h @@ -0,0 +1,51 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OS_WINDOWS_H +#define BOOST_PREDEF_OS_WINDOWS_H + +#include +#include + +/*` +[heading `BOOST_OS_WINDOWS`] + +[@http://en.wikipedia.org/wiki/Category:Microsoft_Windows Microsoft Windows] operating system. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`_WIN32`] [__predef_detection__]] + [[`_WIN64`] [__predef_detection__]] + [[`__WIN32__`] [__predef_detection__]] + [[`__TOS_WIN__`] [__predef_detection__]] + [[`__WINDOWS__`] [__predef_detection__]] + ] + */ + +#define BOOST_OS_WINDOWS BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \ + defined(_WIN32) || defined(_WIN64) || \ + defined(__WIN32__) || defined(__TOS_WIN__) || \ + defined(__WINDOWS__) \ + ) +# undef BOOST_OS_WINDOWS +# define BOOST_OS_WINDOWS BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_OS_WINDOWS +# define BOOST_OS_WINDOWS_AVAILABLE +# include +#endif + +#define BOOST_OS_WINDOWS_NAME "Microsoft Windows" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_OS_WINDOWS,BOOST_OS_WINDOWS_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/other.h b/src/thirdparty/boost_lib/boost/predef/other.h new file mode 100644 index 000000000..04aad1680 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/other.h @@ -0,0 +1,14 @@ +/* +Copyright Rene Rivera 2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_OTHER_H +#define BOOST_PREDEF_OTHER_H + +#include +/*#include */ + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/other/endian.h b/src/thirdparty/boost_lib/boost/predef/other/endian.h new file mode 100644 index 000000000..fd7336474 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/other/endian.h @@ -0,0 +1,204 @@ +/* +Copyright Rene Rivera 2013-2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_ENDIAN_H +#define BOOST_PREDEF_ENDIAN_H + +#include +#include +#include +#include +#include + +/*` +[heading `BOOST_ENDIAN_*`] + +Detection of endian memory ordering. There are four defined macros +in this header that define the various generally possible endian +memory orderings: + +* `BOOST_ENDIAN_BIG_BYTE`, byte-swapped big-endian. +* `BOOST_ENDIAN_BIG_WORD`, word-swapped big-endian. +* `BOOST_ENDIAN_LITTLE_BYTE`, byte-swapped little-endian. +* `BOOST_ENDIAN_LITTLE_WORD`, word-swapped little-endian. + +The detection is conservative in that it only identifies endianness +that it knows for certain. In particular bi-endianness is not +indicated as is it not practically possible to determine the +endianness from anything but an operating system provided +header. And the currently known headers do not define that +programatic bi-endianness is available. + +This implementation is a compilation of various publicly available +information and acquired knowledge: + +# The indispensable documentation of "Pre-defined Compiler Macros" + [@http://sourceforge.net/p/predef/wiki/Endianness Endianness]. +# The various endian specifications available in the + [@http://wikipedia.org/ Wikipedia] computer architecture pages. +# Generally available searches for headers that define endianness. + */ + +#define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_NOT_AVAILABLE +#define BOOST_ENDIAN_BIG_WORD BOOST_VERSION_NUMBER_NOT_AVAILABLE +#define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_NOT_AVAILABLE +#define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_NOT_AVAILABLE + +/* GNU libc provides a header defining __BYTE_ORDER, or _BYTE_ORDER. + * And some OSs provide some for of endian header also. + */ +#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \ + !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD +# if BOOST_LIB_C_GNU +# include +# else +# if BOOST_OS_MACOS +# include +# else +# if BOOST_OS_BSD +# if BOOST_OS_BSD_OPEN +# include +# else +# include +# endif +# endif +# endif +# endif +# if defined(__BYTE_ORDER) +# if (__BYTE_ORDER == __BIG_ENDIAN) +# undef BOOST_ENDIAN_BIG_BYTE +# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +# if (__BYTE_ORDER == __LITTLE_ENDIAN) +# undef BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +# if (__BYTE_ORDER == __PDP_ENDIAN) +# undef BOOST_ENDIAN_LITTLE_WORD +# define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_AVAILABLE +# endif +# endif +# if !defined(__BYTE_ORDER) && defined(_BYTE_ORDER) +# if (_BYTE_ORDER == _BIG_ENDIAN) +# undef BOOST_ENDIAN_BIG_BYTE +# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +# if (_BYTE_ORDER == _LITTLE_ENDIAN) +# undef BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +# if (_BYTE_ORDER == _PDP_ENDIAN) +# undef BOOST_ENDIAN_LITTLE_WORD +# define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_AVAILABLE +# endif +# endif +#endif + +/* Built-in byte-swpped big-endian macros. + */ +#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \ + !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD +# if (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \ + (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)) || \ + defined(__ARMEB__) || \ + defined(__THUMBEB__) || \ + defined(__AARCH64EB__) || \ + defined(_MIPSEB) || \ + defined(__MIPSEB) || \ + defined(__MIPSEB__) +# undef BOOST_ENDIAN_BIG_BYTE +# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +/* Built-in byte-swpped little-endian macros. + */ +#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \ + !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD +# if (defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \ + (defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)) || \ + defined(__ARMEL__) || \ + defined(__THUMBEL__) || \ + defined(__AARCH64EL__) || \ + defined(_MIPSEL) || \ + defined(__MIPSEL) || \ + defined(__MIPSEL__) +# undef BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +/* Some architectures are strictly one endianess (as opposed + * the current common bi-endianess). + */ +#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \ + !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD +# include +# if BOOST_ARCH_M68K || \ + BOOST_ARCH_PARISK || \ + BOOST_ARCH_SPARC || \ + BOOST_ARCH_SYS370 || \ + BOOST_ARCH_SYS390 || \ + BOOST_ARCH_Z +# undef BOOST_ENDIAN_BIG_BYTE +# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +# if BOOST_ARCH_AMD64 || \ + BOOST_ARCH_IA64 || \ + BOOST_ARCH_X86 || \ + BOOST_ARCH_BLACKFIN +# undef BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +/* Windows on ARM, if not otherwise detected/specified, is always + * byte-swaped little-endian. + */ +#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \ + !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD +# if BOOST_ARCH_ARM +# include +# if BOOST_OS_WINDOWS +# undef BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE +# endif +# endif +#endif + +#if BOOST_ENDIAN_BIG_BYTE +# define BOOST_ENDIAN_BIG_BYTE_AVAILABLE +#endif +#if BOOST_ENDIAN_BIG_WORD +# define BOOST_ENDIAN_BIG_WORD_BYTE_AVAILABLE +#endif +#if BOOST_ENDIAN_LITTLE_BYTE +# define BOOST_ENDIAN_LITTLE_BYTE_AVAILABLE +#endif +#if BOOST_ENDIAN_LITTLE_WORD +# define BOOST_ENDIAN_LITTLE_WORD_BYTE_AVAILABLE +#endif + +#define BOOST_ENDIAN_BIG_BYTE_NAME "Byte-Swapped Big-Endian" +#define BOOST_ENDIAN_BIG_WORD_NAME "Word-Swapped Big-Endian" +#define BOOST_ENDIAN_LITTLE_BYTE_NAME "Byte-Swapped Little-Endian" +#define BOOST_ENDIAN_LITTLE_WORD_NAME "Word-Swapped Little-Endian" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_BIG_BYTE,BOOST_ENDIAN_BIG_BYTE_NAME) + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_BIG_WORD,BOOST_ENDIAN_BIG_WORD_NAME) + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_LITTLE_BYTE,BOOST_ENDIAN_LITTLE_BYTE_NAME) + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_LITTLE_WORD,BOOST_ENDIAN_LITTLE_WORD_NAME) + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/platform.h b/src/thirdparty/boost_lib/boost/predef/platform.h new file mode 100644 index 000000000..468a90d38 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/platform.h @@ -0,0 +1,19 @@ +/* +Copyright Rene Rivera 2013 +Copyright (c) Microsoft Corporation 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_PLATFORM_H +#define BOOST_PREDEF_PLATFORM_H + +#include +#include +#include +#include +#include +/*#include */ + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/platform/mingw.h b/src/thirdparty/boost_lib/boost/predef/platform/mingw.h new file mode 100644 index 000000000..6c8d873ca --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/platform/mingw.h @@ -0,0 +1,70 @@ +/* +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_COMPILER_MINGW_H +#define BOOST_PREDEF_COMPILER_MINGW_H + +#include +#include + +/*` +[heading `BOOST_PLAT_MINGW`] + +[@http://en.wikipedia.org/wiki/MinGW MinGW] platform. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MINGW32__`] [__predef_detection__]] + [[`__MINGW64__`] [__predef_detection__]] + + [[`__MINGW64_VERSION_MAJOR`, `__MINGW64_VERSION_MINOR`] [V.R.0]] + [[`__MINGW32_VERSION_MAJOR`, `__MINGW32_VERSION_MINOR`] [V.R.0]] + ] + */ + +#define BOOST_PLAT_MINGW BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__MINGW32__) || defined(__MINGW64__) +# include <_mingw.h> +# if !defined(BOOST_PLAT_MINGW_DETECTION) && (defined(__MINGW64_VERSION_MAJOR) && defined(__MINGW64_VERSION_MINOR)) +# define BOOST_PLAT_MINGW_DETECTION \ + BOOST_VERSION_NUMBER(__MINGW64_VERSION_MAJOR,__MINGW64_VERSION_MINOR,0) +# endif +# if !defined(BOOST_PLAT_MINGW_DETECTION) && (defined(__MINGW32_VERSION_MAJOR) && defined(__MINGW32_VERSION_MINOR)) +# define BOOST_PLAT_MINGW_DETECTION \ + BOOST_VERSION_NUMBER(__MINGW32_MAJOR_VERSION,__MINGW32_MINOR_VERSION,0) +# endif +# if !defined(BOOST_PLAT_MINGW_DETECTION) +# define BOOST_PLAT_MINGW_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_PLAT_MINGW_DETECTION +# define BOOST_PLAT_MINGW_AVAILABLE +# if defined(BOOST_PREDEF_DETAIL_PLAT_DETECTED) +# define BOOST_PLAT_MINGW_EMULATED BOOST_PLAT_MINGW_DETECTION +# else +# undef BOOST_PLAT_MINGW +# define BOOST_PLAT_MINGW BOOST_PLAT_MINGW_DETECTION +# endif +# include +#endif + +#define BOOST_PLAT_MINGW_NAME "MinGW" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW,BOOST_PLAT_MINGW_NAME) + +#ifdef BOOST_PLAT_MINGW_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW_EMULATED,BOOST_PLAT_MINGW_NAME) +#endif + + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/platform/windows_desktop.h b/src/thirdparty/boost_lib/boost/predef/platform/windows_desktop.h new file mode 100644 index 000000000..286c27350 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/platform/windows_desktop.h @@ -0,0 +1,44 @@ +/* +Copyright (c) Microsoft Corporation 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_PLAT_WINDOWS_DESKTOP_H +#define BOOST_PREDEF_PLAT_WINDOWS_DESKTOP_H + +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_DESKTOP`] + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`!WINAPI_FAMILY`] [__predef_detection__]] + [[`WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_WINDOWS_DESKTOP BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS && \ + ( !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) ) +# undef BOOST_PLAT_WINDOWS_DESKTOP +# define BOOST_PLAT_WINDOWS_DESKTOP BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_WINDOWS_DESKTOP +# define BOOST_PLAT_WINDOWS_DESKTOP_AVALIABLE +# include +#endif + +#define BOOST_PLAT_WINDOWS_DESKTOP_NAME "Windows Desktop" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_DESKTOP,BOOST_PLAT_WINDOWS_DESKTOP_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/platform/windows_phone.h b/src/thirdparty/boost_lib/boost/predef/platform/windows_phone.h new file mode 100644 index 000000000..cdf79d1c4 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/platform/windows_phone.h @@ -0,0 +1,42 @@ +/* +Copyright (c) Microsoft Corporation 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_PLAT_WINDOWS_PHONE_H +#define BOOST_PREDEF_PLAT_WINDOWS_PHONE_H + +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_PHONE`] + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP +# undef BOOST_PLAT_WINDOWS_PHONE +# define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_WINDOWS_PHONE +# define BOOST_PLAT_WINDOWS_PHONE_AVALIABLE +# include +#endif + +#define BOOST_PLAT_WINDOWS_PHONE_NAME "Windows Phone" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_PHONE,BOOST_PLAT_WINDOWS_PHONE_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/platform/windows_runtime.h b/src/thirdparty/boost_lib/boost/predef/platform/windows_runtime.h new file mode 100644 index 000000000..14449383d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/platform/windows_runtime.h @@ -0,0 +1,44 @@ +/* +Copyright (c) Microsoft Corporation 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H +#define BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H + +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_RUNTIME`] + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]] + [[`WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && \ + ( WINAPI_FAMILY == WINAPI_FAMILY_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP ) +# undef BOOST_PLAT_WINDOWS_RUNTIME +# define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_WINDOWS_RUNTIME +# define BOOST_PLAT_WINDOWS_RUNTIME_AVALIABLE +# include +#endif + +#define BOOST_PLAT_WINDOWS_RUNTIME_NAME "Windows Runtime" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_RUNTIME,BOOST_PLAT_WINDOWS_RUNTIME_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/platform/windows_store.h b/src/thirdparty/boost_lib/boost/predef/platform/windows_store.h new file mode 100644 index 000000000..0487c0fa2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/platform/windows_store.h @@ -0,0 +1,42 @@ +/* +Copyright (c) Microsoft Corporation 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_PLAT_WINDOWS_STORE_H +#define BOOST_PREDEF_PLAT_WINDOWS_STORE_H + +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_STORE`] + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP +# undef BOOST_PLAT_WINDOWS_STORE +# define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_WINDOWS_STORE +# define BOOST_PLAT_WINDOWS_STORE_AVALIABLE +# include +#endif + +#define BOOST_PLAT_WINDOWS_STORE_NAME "Windows Store" + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_STORE,BOOST_PLAT_WINDOWS_STORE_NAME) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/version.h b/src/thirdparty/boost_lib/boost/predef/version.h new file mode 100644 index 000000000..1e85df74f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/version.h @@ -0,0 +1,15 @@ +/* +Copyright Rene Rivera 2014 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_VERSION_H +#define BOOST_PREDEF_VERSION_H + +#include + +#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,1,0) + +#endif diff --git a/src/thirdparty/boost_lib/boost/predef/version_number.h b/src/thirdparty/boost_lib/boost/predef/version_number.h new file mode 100644 index 000000000..b77391925 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/predef/version_number.h @@ -0,0 +1,54 @@ +/* +Copyright Rene Rivera 2005 +Copyright Rene Rivera 2008-2013 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE_1_0.txt or copy at +http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_PREDEF_VERSION_NUMBER_H +#define BOOST_PREDEF_VERSION_NUMBER_H + +/*` +[heading `BOOST_VERSION_NUMBER`] + +`` +BOOST_VERSION_NUMBER(major,minor,patch) +`` + +Defines standard version numbers, with these properties: + +* Decimal base whole numbers in the range \[0,1000000000). + The number range is designed to allow for a (2,2,5) triplet. + Which fits within a 32 bit value. +* The `major` number can be in the \[0,99\] range. +* The `minor` number can be in the \[0,99\] range. +* The `patch` number can be in the \[0,99999\] range. +* Values can be specified in any base. As the defined value + is an constant expression. +* Value can be directly used in both preprocessor and compiler + expressions for comparison to other similarly defined values. +* The implementation enforces the individual ranges for the + major, minor, and patch numbers. And values over the ranges + are truncated (modulo). + +*/ +#define BOOST_VERSION_NUMBER(major,minor,patch) \ + ( (((major)%100)*10000000) + (((minor)%100)*100000) + ((patch)%100000) ) + +#define BOOST_VERSION_NUMBER_MAX \ + BOOST_VERSION_NUMBER(99,99,99999) + +#define BOOST_VERSION_NUMBER_ZERO \ + BOOST_VERSION_NUMBER(0,0,0) + +#define BOOST_VERSION_NUMBER_MIN \ + BOOST_VERSION_NUMBER(0,0,1) + +#define BOOST_VERSION_NUMBER_AVAILABLE \ + BOOST_VERSION_NUMBER_MIN + +#define BOOST_VERSION_NUMBER_NOT_AVAILABLE \ + BOOST_VERSION_NUMBER_ZERO + +#endif diff --git a/src/thirdparty/boost_lib/boost/preprocessor.hpp b/src/thirdparty/boost_lib/boost/preprocessor.hpp index 6f5c822f8..b5c928e38 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor.hpp @@ -7,7 +7,7 @@ # * http://www.boost.org/LICENSE_1_0.txt) # */ # -# /* Revised by Paul Mensonides (2002) */ +# /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org/libs/preprocessor for documentation. */ # diff --git a/src/thirdparty/boost_lib/boost/preprocessor/config/config.hpp b/src/thirdparty/boost_lib/boost/preprocessor/config/config.hpp index d02eb58dc..b6afbabd2 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/config/config.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/config/config.hpp @@ -45,7 +45,7 @@ # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) # elif defined(__BORLANDC__) || defined(__IBMC__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_BCC()) -# elif defined(_MSC_VER) +# elif defined(_MSC_VER) && !defined(__clang__) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC()) # else # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) @@ -72,16 +72,15 @@ # # if !defined BOOST_PP_VARIADICS # /* variadic support explicitly disabled for all untested compilers */ -# if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __clang__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI +# if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI # define BOOST_PP_VARIADICS 0 +# /* Clang, all versions */ +# elif defined __clang__ +# define BOOST_PP_VARIADICS 1 # /* VC++ (C/C++) */ # elif defined _MSC_VER && _MSC_VER >= 1400 && !defined __EDG__ -# if _MSC_VER >= 1400 -# define BOOST_PP_VARIADICS 1 -# define BOOST_PP_VARIADICS_MSVC 1 -# else -# define BOOST_PP_VARIADICS 0 -# endif +# define BOOST_PP_VARIADICS 1 +# define BOOST_PP_VARIADICS_MSVC 1 # /* Wave (C/C++), GCC (C++) */ # elif defined __WAVE__ && __WAVE_HAS_VARIADICS__ || defined __GNUC__ && __GXX_EXPERIMENTAL_CXX0X__ # define BOOST_PP_VARIADICS 1 diff --git a/src/thirdparty/boost_lib/boost/preprocessor/seq.hpp b/src/thirdparty/boost_lib/boost/preprocessor/seq.hpp index 6d78f4319..cde208ce1 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/seq.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/seq.hpp @@ -39,5 +39,6 @@ # include # include # include +# include # # endif diff --git a/src/thirdparty/boost_lib/boost/preprocessor/seq/variadic_seq_to_seq.hpp b/src/thirdparty/boost_lib/boost/preprocessor/seq/variadic_seq_to_seq.hpp new file mode 100644 index 000000000..f94a2bfd1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/seq/variadic_seq_to_seq.hpp @@ -0,0 +1,28 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2012. * +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_SEQ_VARIADIC_SEQ_TO_SEQ_HPP +# define BOOST_PREPROCESSOR_SEQ_VARIADIC_SEQ_TO_SEQ_HPP +# +# include +# include +# +# /* BOOST_PP_VARIADIC_SEQ_TO_SEQ */ +# +# if BOOST_PP_VARIADICS +# define BOOST_PP_VARIADIC_SEQ_TO_SEQ(vseq) BOOST_PP_CAT(BOOST_PP_VARIADIC_SEQ_TO_SEQ_A vseq, 0) +# define BOOST_PP_VARIADIC_SEQ_TO_SEQ_A(...) ((__VA_ARGS__)) BOOST_PP_VARIADIC_SEQ_TO_SEQ_B +# define BOOST_PP_VARIADIC_SEQ_TO_SEQ_B(...) ((__VA_ARGS__)) BOOST_PP_VARIADIC_SEQ_TO_SEQ_A +# define BOOST_PP_VARIADIC_SEQ_TO_SEQ_A0 +# define BOOST_PP_VARIADIC_SEQ_TO_SEQ_B0 +# endif +# +# endif diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple.hpp index 0f4976b7a..76fad3650 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/tuple.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple.hpp @@ -8,7 +8,7 @@ # */ # # /* Revised by Paul Mensonides (2002) */ -# /* Revised by Edward Diener (2011) */ +# /* Revised by Edward Diener (2011,2013) */ # # /* See http://www.boost.org for most recent version. */ # @@ -18,7 +18,14 @@ # include # include # include +# include +# include +# include +# include +# include # include +# include +# include # include # include # include diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/insert.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/insert.hpp new file mode 100644 index 000000000..ce4544f08 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/insert.hpp @@ -0,0 +1,37 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_INSERT_HPP +# define BOOST_PREPROCESSOR_TUPLE_INSERT_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# +# /* BOOST_PP_TUPLE_INSERT */ +# +# define BOOST_PP_TUPLE_INSERT(tuple, i, elem) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_INSERT(BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \ +/**/ +# +# /* BOOST_PP_TUPLE_INSERT_D */ +# +# define BOOST_PP_TUPLE_INSERT_D(d, tuple, i, elem) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_INSERT_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \ +/**/ +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_INSERT_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/pop_back.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/pop_back.hpp new file mode 100644 index 000000000..3ac414ba9 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/pop_back.hpp @@ -0,0 +1,64 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_POP_BACK_HPP +# define BOOST_PREPROCESSOR_TUPLE_POP_BACK_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_TUPLE_POP_BACK */ +# +# define BOOST_PP_TUPLE_POP_BACK(tuple) \ + BOOST_PP_IIF \ + ( \ + BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \ + BOOST_PP_TUPLE_POP_BACK_EXEC, \ + BOOST_PP_TUPLE_POP_BACK_RETURN \ + ) \ + (tuple) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_BACK_EXEC(tuple) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_BACK_RETURN(tuple) tuple +# +# /* BOOST_PP_TUPLE_POP_BACK_Z */ +# +# define BOOST_PP_TUPLE_POP_BACK_Z(z, tuple) \ + BOOST_PP_IIF \ + ( \ + BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \ + BOOST_PP_TUPLE_POP_BACK_Z_EXEC, \ + BOOST_PP_TUPLE_POP_BACK_Z_RETURN \ + ) \ + (z, tuple) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_BACK_Z_EXEC(z, tuple) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_BACK_Z_RETURN(z, tuple) tuple +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_POP_BACK_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/pop_front.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/pop_front.hpp new file mode 100644 index 000000000..fafaa77d1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/pop_front.hpp @@ -0,0 +1,65 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_POP_FRONT_HPP +# define BOOST_PREPROCESSOR_TUPLE_POP_FRONT_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# include +# include +# include +# +# +# /* BOOST_PP_TUPLE_POP_FRONT */ +# +# define BOOST_PP_TUPLE_POP_FRONT(tuple) \ + BOOST_PP_IIF \ + ( \ + BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \ + BOOST_PP_TUPLE_POP_FRONT_EXEC, \ + BOOST_PP_TUPLE_POP_FRONT_RETURN \ + ) \ + (tuple) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_FRONT_EXEC(tuple) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_FRONT_RETURN(tuple) tuple +# +# /* BOOST_PP_TUPLE_POP_FRONT_Z */ +# +# define BOOST_PP_TUPLE_POP_FRONT_Z(z, tuple) \ + BOOST_PP_IIF \ + ( \ + BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \ + BOOST_PP_TUPLE_POP_FRONT_Z_EXEC, \ + BOOST_PP_TUPLE_POP_FRONT_Z_RETURN \ + ) \ + (z, tuple) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_FRONT_Z_EXEC(z, tuple) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \ +/**/ +# +# define BOOST_PP_TUPLE_POP_FRONT_Z_RETURN(z, tuple) tuple +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_POP_FRONT_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/push_back.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/push_back.hpp new file mode 100644 index 000000000..2ae8f6396 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/push_back.hpp @@ -0,0 +1,31 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_PUSH_BACK_HPP +# define BOOST_PREPROCESSOR_TUPLE_PUSH_BACK_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# +# /* BOOST_PP_TUPLE_PUSH_BACK */ +# +# define BOOST_PP_TUPLE_PUSH_BACK(tuple, elem) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_PUSH_BACK(BOOST_PP_TUPLE_TO_ARRAY(tuple), elem)) \ +/**/ +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_PUSH_BACK_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/push_front.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/push_front.hpp new file mode 100644 index 000000000..81fea8592 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/push_front.hpp @@ -0,0 +1,32 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_PUSH_FRONT_HPP +# define BOOST_PREPROCESSOR_TUPLE_PUSH_FRONT_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# +# +# /* BOOST_PP_TUPLE_PUSH_FRONT */ +# +# define BOOST_PP_TUPLE_PUSH_FRONT(tuple, elem) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_PUSH_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple), elem)) \ +/**/ +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_PUSH_FRONT_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/rem.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/rem.hpp index af668a02e..270c31ab3 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/tuple/rem.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/rem.hpp @@ -1,7 +1,7 @@ # /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002-2011. * -# * (C) Copyright Edward Diener 2011. * +# * (C) Copyright Edward Diener 2011,2013. * # * 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) * @@ -27,7 +27,10 @@ # # /* BOOST_PP_TUPLE_REM */ # -# if BOOST_PP_VARIADICS +/* + VC++8.0 cannot handle the variadic version of BOOST_PP_TUPLE_REM(size) +*/ +# if BOOST_PP_VARIADICS && !(BOOST_PP_VARIADICS_MSVC && _MSC_VER == 1400) # define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM # else # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/remove.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/remove.hpp new file mode 100644 index 000000000..25fa37619 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/remove.hpp @@ -0,0 +1,64 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_REMOVE_HPP +# define BOOST_PREPROCESSOR_TUPLE_REMOVE_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_TUPLE_REMOVE */ +# +# define BOOST_PP_TUPLE_REMOVE(tuple, i) \ + BOOST_PP_IIF \ + ( \ + BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \ + BOOST_PP_TUPLE_REMOVE_EXEC, \ + BOOST_PP_TUPLE_REMOVE_RETURN \ + ) \ + (tuple, i) \ +/**/ +# +# define BOOST_PP_TUPLE_REMOVE_EXEC(tuple, i) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REMOVE(BOOST_PP_TUPLE_TO_ARRAY(tuple), i)) \ +/**/ +# +# define BOOST_PP_TUPLE_REMOVE_RETURN(tuple, i) tuple +# +# /* BOOST_PP_TUPLE_REMOVE_D */ +# +# define BOOST_PP_TUPLE_REMOVE_D(d, tuple, i) \ + BOOST_PP_IIF \ + ( \ + BOOST_PP_GREATER_D(d, BOOST_PP_TUPLE_SIZE(tuple), 1), \ + BOOST_PP_TUPLE_REMOVE_D_EXEC, \ + BOOST_PP_TUPLE_REMOVE_D_RETURN \ + ) \ + (d, tuple, i) \ +/**/ +# +# define BOOST_PP_TUPLE_REMOVE_D_EXEC(d, tuple, i) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REMOVE_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i)) \ +/**/ +# +# define BOOST_PP_TUPLE_REMOVE_D_RETURN(d, tuple, i) tuple +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_REMOVE_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/replace.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/replace.hpp new file mode 100644 index 000000000..320ef9e95 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/replace.hpp @@ -0,0 +1,37 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2013. +# * 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 for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_REPLACE_HPP +# define BOOST_PREPROCESSOR_TUPLE_REPLACE_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# include +# +# /* BOOST_PP_TUPLE_REPLACE */ +# +# define BOOST_PP_TUPLE_REPLACE(tuple, i, elem) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REPLACE(BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \ +/**/ +# +# /* BOOST_PP_TUPLE_REPLACE_D */ +# +# define BOOST_PP_TUPLE_REPLACE_D(d, tuple, i, elem) \ + BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REPLACE_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \ +/**/ +# +# endif // BOOST_PP_VARIADICS +# +# endif // BOOST_PREPROCESSOR_TUPLE_REPLACE_HPP diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/reverse.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/reverse.hpp index c4f263ad0..489c44292 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/tuple/reverse.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/reverse.hpp @@ -18,6 +18,8 @@ # include # include # include +# include +# include # # /* BOOST_PP_TUPLE_REVERSE */ # @@ -26,10 +28,11 @@ # define BOOST_PP_TUPLE_REVERSE(...) BOOST_PP_TUPLE_REVERSE_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REVERSE_O_, __VA_ARGS__), (__VA_ARGS__)) # define BOOST_PP_TUPLE_REVERSE_I(m, args) BOOST_PP_TUPLE_REVERSE_II(m, args) # define BOOST_PP_TUPLE_REVERSE_II(m, args) BOOST_PP_CAT(m ## args,) +# define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_TUPLE_SIZE(tuple)) tuple # else # define BOOST_PP_TUPLE_REVERSE(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REVERSE_O_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_VARIADIC_SIZE tuple) tuple # endif -# define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_VARIADIC_SIZE tuple) tuple # define BOOST_PP_TUPLE_REVERSE_O_2(size, tuple) BOOST_PP_TUPLE_REVERSE_O_1(tuple) # else # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_array.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_array.hpp index 1b994f3f3..0a5281123 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_array.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_array.hpp @@ -16,6 +16,7 @@ # include # include # include +# include # include # # /* BOOST_PP_TUPLE_TO_ARRAY */ @@ -25,10 +26,11 @@ # define BOOST_PP_TUPLE_TO_ARRAY(...) BOOST_PP_TUPLE_TO_ARRAY_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_ARRAY_, __VA_ARGS__), (__VA_ARGS__)) # define BOOST_PP_TUPLE_TO_ARRAY_I(m, args) BOOST_PP_TUPLE_TO_ARRAY_II(m, args) # define BOOST_PP_TUPLE_TO_ARRAY_II(m, args) BOOST_PP_CAT(m ## args,) +# define BOOST_PP_TUPLE_TO_ARRAY_1(tuple) (BOOST_PP_TUPLE_SIZE(tuple), tuple) # else # define BOOST_PP_TUPLE_TO_ARRAY(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_ARRAY_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_TO_ARRAY_1(tuple) (BOOST_PP_VARIADIC_SIZE tuple, tuple) # endif -# define BOOST_PP_TUPLE_TO_ARRAY_1(tuple) (BOOST_PP_VARIADIC_SIZE tuple, tuple) # define BOOST_PP_TUPLE_TO_ARRAY_2(size, tuple) (size, tuple) # else # define BOOST_PP_TUPLE_TO_ARRAY(size, tuple) (size, tuple) diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_list.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_list.hpp index 2a9d6fe5f..da7828f7d 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_list.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_list.hpp @@ -18,6 +18,7 @@ # include # include # include +# include # include # # /* BOOST_PP_TUPLE_TO_LIST */ @@ -27,10 +28,11 @@ # define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__)) # define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args) # define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,) +# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_TUPLE_SIZE(tuple)) tuple # else # define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple # endif -# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple # define BOOST_PP_TUPLE_TO_LIST_O_2(size, tuple) BOOST_PP_TUPLE_TO_LIST_O_1(tuple) # else # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() diff --git a/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_seq.hpp b/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_seq.hpp index 1fb7b811c..8bd8485a9 100644 --- a/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_seq.hpp +++ b/src/thirdparty/boost_lib/boost/preprocessor/tuple/to_seq.hpp @@ -16,6 +16,7 @@ # include # include # include +# include # include # # /* BOOST_PP_TUPLE_TO_SEQ */ @@ -25,10 +26,11 @@ # define BOOST_PP_TUPLE_TO_SEQ(...) BOOST_PP_TUPLE_TO_SEQ_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_SEQ_O_, __VA_ARGS__), (__VA_ARGS__)) # define BOOST_PP_TUPLE_TO_SEQ_I(m, args) BOOST_PP_TUPLE_TO_SEQ_II(m, args) # define BOOST_PP_TUPLE_TO_SEQ_II(m, args) BOOST_PP_CAT(m ## args,) +# define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_TUPLE_SIZE(tuple)) tuple # else # define BOOST_PP_TUPLE_TO_SEQ(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_SEQ_O_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_VARIADIC_SIZE tuple) tuple # endif -# define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_VARIADIC_SIZE tuple) tuple # define BOOST_PP_TUPLE_TO_SEQ_O_2(size, tuple) BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) # else # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() diff --git a/src/thirdparty/boost_lib/boost/program_options.hpp b/src/thirdparty/boost_lib/boost/program_options.hpp index 9d12b082f..dc3501195 100644 --- a/src/thirdparty/boost_lib/boost/program_options.hpp +++ b/src/thirdparty/boost_lib/boost/program_options.hpp @@ -8,7 +8,7 @@ #ifndef PROGRAM_OPTIONS_VP_2003_05_19 #define PROGRAM_OPTIONS_VP_2003_05_19 -#if _MSC_VER >= 1020 +#if defined(_MSC_VER) #pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/progress.hpp b/src/thirdparty/boost_lib/boost/progress.hpp index de5fe9690..62bece083 100644 --- a/src/thirdparty/boost_lib/boost/progress.hpp +++ b/src/thirdparty/boost_lib/boost/progress.hpp @@ -20,7 +20,7 @@ #define BOOST_PROGRESS_HPP #include -#include // for noncopyable +#include #include // for uintmax_t #include // for ostream, cout, etc #include // for string @@ -77,20 +77,20 @@ class progress_timer : public timer, private noncopyable class progress_display : private noncopyable { public: - explicit progress_display( unsigned long expected_count, + 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); } + : noncopyable(), m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count_); } - void restart( unsigned long expected_count ) + void restart( unsigned long expected_count_ ) // Effects: display appropriate scale - // Postconditions: count()==0, expected_count()==expected_count + // Postconditions: count()==0, expected_count()==expected_count_ { _count = _next_tic_count = _tic = 0; - _expected_count = expected_count; + _expected_count = expected_count_; m_os << m_s1 << "0% 10 20 30 40 50 60 70 80 90 100%\n" << m_s2 << "|----|----|----|----|----|----|----|----|----|----|" diff --git a/src/thirdparty/boost_lib/boost/random.hpp b/src/thirdparty/boost_lib/boost/random.hpp index d05f2f3d9..de0a97d6a 100644 --- a/src/thirdparty/boost_lib/boost/random.hpp +++ b/src/thirdparty/boost_lib/boost/random.hpp @@ -7,7 +7,7 @@ * * See http://www.boost.org/libs/random for documentation. * - * $Id: random.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $ + * $Id$ * * Revision history * 2000-02-18 portability fixes (thanks to Beman Dawes) diff --git a/src/thirdparty/boost_lib/boost/range.hpp b/src/thirdparty/boost_lib/boost/range.hpp index 948c3d75e..179ae2249 100644 --- a/src/thirdparty/boost_lib/boost/range.hpp +++ b/src/thirdparty/boost_lib/boost/range.hpp @@ -11,23 +11,13 @@ #ifndef BOOST_RANGE_HPP_27_07_04 #define BOOST_RANGE_HPP_27_07_04 -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif -#if _MSC_VER == 1300 // experiment - -#include -#include -#include - -#else - #include #include #include #include -#endif // _MSC_VER == 1300 // experiment - #endif diff --git a/src/thirdparty/boost_lib/boost/ref.hpp b/src/thirdparty/boost_lib/boost/ref.hpp index 6058d6983..17b56ec00 100644 --- a/src/thirdparty/boost_lib/boost/ref.hpp +++ b/src/thirdparty/boost_lib/boost/ref.hpp @@ -1,189 +1,17 @@ -#ifndef BOOST_REF_HPP_INCLUDED -#define BOOST_REF_HPP_INCLUDED +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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) + */ -// MS compatible compilers support #pragma once +#ifndef BOOST_REF_HPP +#define BOOST_REF_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include -#include -#include -#include - -// -// ref.hpp - ref/cref, useful helper functions -// -// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2001, 2002 Peter Dimov -// Copyright (C) 2002 David Abrahams -// -// 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/bind/ref.html for documentation. -// - -namespace boost -{ - -template class reference_wrapper -{ -public: - typedef T type; +// The header file at this path is deprecated; +// use boost/core/ref.hpp instead. -#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) - - explicit reference_wrapper(T& t): t_(&t) {} - -#else - - explicit reference_wrapper(T& t): t_(boost::addressof(t)) {} +#include #endif - - operator T& () const { return *t_; } - - T& get() const { return *t_; } - - T* get_pointer() const { return t_; } - -private: - - T* t_; -}; - -# if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) -# define BOOST_REF_CONST -# else -# define BOOST_REF_CONST const -# endif - -template inline reference_wrapper BOOST_REF_CONST ref(T & t) -{ - return reference_wrapper(t); -} - -template inline reference_wrapper BOOST_REF_CONST cref(T const & t) -{ - return reference_wrapper(t); -} - -# undef BOOST_REF_CONST - -# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -template -class is_reference_wrapper - : public mpl::false_ -{ -}; - -template -class unwrap_reference -{ - public: - typedef T type; -}; - -# define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \ -template \ -class is_reference_wrapper< X > \ - : public mpl::true_ \ -{ \ -}; \ -\ -template \ -class unwrap_reference< X > \ -{ \ - public: \ - typedef T type; \ -}; \ -/**/ - -AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper) -#if !defined(BOOST_NO_CV_SPECIALIZATIONS) -AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper const) -AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper volatile) -AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper const volatile) -#endif - -# undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF - -# else // no partial specialization - -} // namespace boost - -#include - -namespace boost -{ - -namespace detail -{ - typedef char (&yes_reference_wrapper_t)[1]; - typedef char (&no_reference_wrapper_t)[2]; - - no_reference_wrapper_t is_reference_wrapper_test(...); - - template - yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper >); - - template - struct reference_unwrapper - { - template - struct apply - { - typedef T type; - }; - }; - - template<> - struct reference_unwrapper - { - template - struct apply - { - typedef typename T::type type; - }; - }; -} - -template -class is_reference_wrapper -{ - public: - BOOST_STATIC_CONSTANT( - bool, value = ( - sizeof(detail::is_reference_wrapper_test(type())) - == sizeof(detail::yes_reference_wrapper_t))); - - typedef ::boost::mpl::bool_ type; -}; - -template -class unwrap_reference - : public detail::reference_unwrapper< - is_reference_wrapper::value - >::template apply -{}; - -# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -template inline typename unwrap_reference::type& -unwrap_ref(T& t) -{ - return t; -} - -template inline T* get_pointer( reference_wrapper const & r ) -{ - return r.get_pointer(); -} - -} // namespace boost - -#endif // #ifndef BOOST_REF_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/serialization/access.hpp b/src/thirdparty/boost_lib/boost/serialization/access.hpp index 40256d6cd..ec88ff5ac 100644 --- a/src/thirdparty/boost_lib/boost/serialization/access.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/access.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_ACCESS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/array.hpp b/src/thirdparty/boost_lib/boost/serialization/array.hpp index 3391a96f5..35c640ce4 100644 --- a/src/thirdparty/boost_lib/boost/serialization/array.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/array.hpp @@ -6,10 +6,14 @@ // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#include // msvc 6.0 needs this for warning suppression + #include #include // std::size_t -#include -#include // msvc 6.0 needs this for warning suppression +#ifndef BOOST_NO_CXX11_HDR_ARRAY +#include +#endif + #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; @@ -97,9 +101,9 @@ class array : template void serialize(Archive &ar, const unsigned int version) { - typedef BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::use_array_optimization::template apply< - BOOST_DEDUCED_TYPENAME remove_const< T >::type + typename remove_const< T >::type >::type use_optimized; serialize_optimized(ar,version,use_optimized()); } @@ -128,12 +132,26 @@ array< T > make_array( T* t, std::size_t s){ return array< T >(t, s); } +// implement serialization for boost::array template void serialize(Archive& ar, boost::array& a, const unsigned int /* version */) { - ar & boost::serialization::make_nvp("elems",a.elems); + ar & boost::serialization::make_nvp("elems", a.elems); } +#ifndef BOOST_NO_CXX11_HDR_ARRAY +// implement serialization for std::array +template +void serialize(Archive& ar, std::array& a, const unsigned int /* version */) +{ + ar & boost::serialization::make_nvp( + "elems", + *static_cast(static_cast(a.data())) + ); + +} +#endif + } } // end namespace boost::serialization #ifdef __BORLANDC__ @@ -145,7 +163,7 @@ namespace boost { namespace serialization { \ template <> struct use_array_optimization { \ template \ struct apply : boost::mpl::apply1::type \ + , typename boost::remove_const::type \ >::type {}; \ }; }} #endif // __BORLANDC__ diff --git a/src/thirdparty/boost_lib/boost/serialization/assume_abstract.hpp b/src/thirdparty/boost_lib/boost/serialization/assume_abstract.hpp index 4a8123a31..a5cb2f55a 100644 --- a/src/thirdparty/boost_lib/boost/serialization/assume_abstract.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/assume_abstract.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/base_object.hpp b/src/thirdparty/boost_lib/boost/serialization/base_object.hpp index b840d25e9..562dbd506 100644 --- a/src/thirdparty/boost_lib/boost/serialization/base_object.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/base_object.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_BASE_OBJECT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -48,7 +48,7 @@ namespace detail template struct base_cast { - typedef BOOST_DEDUCED_TYPENAME + typedef typename mpl::if_< is_const, const B, @@ -74,7 +74,7 @@ namespace detail } }; static void const * invoke(){ - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< is_polymorphic, mpl::identity, mpl::identity @@ -95,12 +95,12 @@ base_object(const Derived & d) } #else template -BOOST_DEDUCED_TYPENAME detail::base_cast::type & +typename detail::base_cast::type & base_object(Derived &d) { BOOST_STATIC_ASSERT(( is_base_and_derived::value)); BOOST_STATIC_ASSERT(! is_pointer::value); - typedef BOOST_DEDUCED_TYPENAME detail::base_cast::type type; + typedef typename detail::base_cast::type type; detail::base_register::invoke(); return access::cast_reference(d); } diff --git a/src/thirdparty/boost_lib/boost/serialization/binary_object.hpp b/src/thirdparty/boost_lib/boost/serialization/binary_object.hpp index cbc19f46f..7e2307680 100644 --- a/src/thirdparty/boost_lib/boost/serialization/binary_object.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/binary_object.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_BINARY_OBJECT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/bitset.hpp b/src/thirdparty/boost_lib/boost/serialization/bitset.hpp index 0e109ce29..78f9bd743 100644 --- a/src/thirdparty/boost_lib/boost/serialization/bitset.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/bitset.hpp @@ -11,7 +11,7 @@ #define BOOST_SERIALIZATION_BITSET_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/collection_traits.hpp b/src/thirdparty/boost_lib/boost/serialization/collection_traits.hpp index 60453c793..b3fe84342 100644 --- a/src/thirdparty/boost_lib/boost/serialization/collection_traits.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/collection_traits.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/collections_load_imp.hpp b/src/thirdparty/boost_lib/boost/serialization/collections_load_imp.hpp index 11b00cdb8..2291e7422 100644 --- a/src/thirdparty/boost_lib/boost/serialization/collections_load_imp.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/collections_load_imp.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -51,14 +51,14 @@ namespace stl { template struct archive_input_seq { - inline BOOST_DEDUCED_TYPENAME Container::iterator + inline typename Container::iterator operator()( Archive &ar, Container &s, const unsigned int v, - BOOST_DEDUCED_TYPENAME Container::iterator hint + typename Container::iterator hint ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); @@ -72,18 +72,18 @@ struct archive_input_seq template struct archive_input_map { - inline BOOST_DEDUCED_TYPENAME Container::iterator + inline typename Container::iterator operator()( Archive &ar, Container &s, const unsigned int v, - BOOST_DEDUCED_TYPENAME Container::iterator hint + typename Container::iterator hint ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - BOOST_DEDUCED_TYPENAME Container::iterator result = + typename Container::iterator result = s.insert(hint, t.reference()); // note: the following presumes that the map::value_type was NOT tracked // in the archive. This is the usual case, but here there is no way @@ -100,18 +100,18 @@ struct archive_input_map template struct archive_input_set { - inline BOOST_DEDUCED_TYPENAME Container::iterator + inline typename Container::iterator operator()( Archive &ar, Container &s, const unsigned int v, - BOOST_DEDUCED_TYPENAME Container::iterator hint + typename Container::iterator hint ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - BOOST_DEDUCED_TYPENAME Container::iterator result = + typename Container::iterator result = s.insert(hint, t.reference()); ar.reset_object_address(& (* result), & t.reference()); return result; @@ -138,12 +138,12 @@ template inline void load_collection(Archive & ar, Container &s) { s.clear(); - collection_size_type count; const boost::archive::library_version_type library_version( ar.get_library_version() ); // retrieve number of elements item_version_type item_version(0); + collection_size_type count; ar >> BOOST_SERIALIZATION_NVP(count); if(boost::archive::library_version_type(3) < library_version){ ar >> BOOST_SERIALIZATION_NVP(item_version); @@ -152,7 +152,7 @@ inline void load_collection(Archive & ar, Container &s) R rx; rx(s, count); InputFunction ifunc; - BOOST_DEDUCED_TYPENAME Container::iterator hint; + typename Container::iterator hint; hint = s.begin(); while(count-- > 0){ hint = ifunc(ar, s, item_version, hint); diff --git a/src/thirdparty/boost_lib/boost/serialization/collections_save_imp.hpp b/src/thirdparty/boost_lib/boost/serialization/collections_save_imp.hpp index 5151c4b8b..f3cabfcf3 100644 --- a/src/thirdparty/boost_lib/boost/serialization/collections_save_imp.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/collections_save_imp.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -34,14 +34,16 @@ namespace stl { // template -inline void save_collection(Archive & ar, const Container &s) +inline void save_collection( + Archive & ar, + const Container &s, + collection_size_type count) { + ar << BOOST_SERIALIZATION_NVP(count); // record number of elements - collection_size_type count(s.size()); const item_version_type item_version( - version::value + version::value ); - ar << BOOST_SERIALIZATION_NVP(count); #if 0 boost::archive::library_version_type library_version( ar.get_library_version() @@ -53,7 +55,7 @@ inline void save_collection(Archive & ar, const Container &s) ar << BOOST_SERIALIZATION_NVP(item_version); #endif - BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin(); + typename Container::const_iterator it = s.begin(); while(count-- > 0){ // note borland emits a no-op without the explicit namespace boost::serialization::save_construct_data_adl( @@ -65,6 +67,14 @@ inline void save_collection(Archive & ar, const Container &s) } } +template +inline void save_collection(Archive & ar, const Container &s) +{ + // record number of elements + collection_size_type count(s.size()); + save_collection(ar, s, count); +} + } // namespace stl } // namespace serialization } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/serialization/complex.hpp b/src/thirdparty/boost_lib/boost/serialization/complex.hpp index 3e222e42a..b4ef44cf9 100644 --- a/src/thirdparty/boost_lib/boost/serialization/complex.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/complex.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_COMPLEX_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/deque.hpp b/src/thirdparty/boost_lib/boost/serialization/deque.hpp index 340d5feed..701290291 100644 --- a/src/thirdparty/boost_lib/boost/serialization/deque.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/deque.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_DEQUE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/detail/get_data.hpp b/src/thirdparty/boost_lib/boost/serialization/detail/get_data.hpp index 3cbcb4a30..da8921355 100644 --- a/src/thirdparty/boost_lib/boost/serialization/detail/get_data.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/detail/get_data.hpp @@ -9,7 +9,7 @@ #define BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/detail/shared_count_132.hpp b/src/thirdparty/boost_lib/boost/serialization/detail/shared_count_132.hpp index c42355b1e..a63e48849 100644 --- a/src/thirdparty/boost_lib/boost/serialization/detail/shared_count_132.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/detail/shared_count_132.hpp @@ -3,7 +3,7 @@ // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -201,12 +201,12 @@ class sp_counted_base #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) -template void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter< T > const &, int) +template void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &, int) { boost::sp_scalar_constructor_hook(px, sizeof(T), pn); } -template void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter< T > const &, int) +template void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &, int) { boost::sp_array_constructor_hook(px); } @@ -215,12 +215,12 @@ template void cbi_call_constructor_hook(sp_counted_base *, P c { } -template void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter< T > const &, int) +template void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &, int) { boost::sp_scalar_destructor_hook(px, sizeof(T), pn); } -template void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter< T > const &, int) +template void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &, int) { boost::sp_array_destructor_hook(px); } diff --git a/src/thirdparty/boost_lib/boost/serialization/detail/shared_ptr_132.hpp b/src/thirdparty/boost_lib/boost/serialization/detail/shared_ptr_132.hpp index b5f2b2156..969b53a77 100644 --- a/src/thirdparty/boost_lib/boost/serialization/detail/shared_ptr_132.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/detail/shared_ptr_132.hpp @@ -114,7 +114,7 @@ template class shared_ptr typedef T element_type; typedef T value_type; typedef T * pointer; - typedef BOOST_DEDUCED_TYPENAME detail::shared_ptr_traits< T >::reference reference; + typedef typename detail::shared_ptr_traits< T >::reference reference; shared_ptr(): px(0), pn() // never throws in 1.30+ { @@ -353,17 +353,6 @@ template inline bool operator!=(shared_ptr< T > const & a, sha return a.get() != b.get(); } -#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 - -// Resolve the ambiguity between our op!= and the one in rel_ops - -template inline bool operator!=(shared_ptr< T > const & a, shared_ptr< T > const & b) -{ - return a.get() != b.get(); -} - -#endif - template inline bool operator<(shared_ptr< T > const & a, shared_ptr const & b) { return a._internal_less(b); @@ -421,33 +410,16 @@ template inline T * get_pointer(shared_ptr< T > const & p) // operator<< -#if defined(__GNUC__) && (__GNUC__ < 3) -template std::ostream & operator<< (std::ostream & os, shared_ptr const & p) -{ - os << p.get(); - return os; -} - -#else - -# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT) -// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL -using std::basic_ostream; -template basic_ostream & operator<< (basic_ostream & os, shared_ptr const & p) -# else template std::basic_ostream & operator<< (std::basic_ostream & os, shared_ptr const & p) -# endif { os << p.get(); return os; } -#endif - // get_deleter (experimental) -#if (defined(__GNUC__) && (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)) +#if defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238) // g++ 2.9x doesn't allow static_cast(void *) // apparently EDG 2.38 also doesn't accept it diff --git a/src/thirdparty/boost_lib/boost/serialization/detail/stack_constructor.hpp b/src/thirdparty/boost_lib/boost/serialization/detail/stack_constructor.hpp index de623b0d4..7c74c181a 100644 --- a/src/thirdparty/boost_lib/boost/serialization/detail/stack_constructor.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/detail/stack_constructor.hpp @@ -2,14 +2,10 @@ #define BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif -#if defined(_MSC_VER) && (_MSC_VER <= 1020) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif - /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // collections_load_imp.hpp: serialization for loading stl collections @@ -38,7 +34,7 @@ struct stack_allocate return * address(); } private: - typedef BOOST_DEDUCED_TYPENAME boost::aligned_storage< + typedef typename boost::aligned_storage< sizeof(T), #if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560)) 8 diff --git a/src/thirdparty/boost_lib/boost/serialization/ephemeral.hpp b/src/thirdparty/boost_lib/boost/serialization/ephemeral.hpp index f559bec99..b913fef0b 100644 --- a/src/thirdparty/boost_lib/boost/serialization/ephemeral.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/ephemeral.hpp @@ -3,7 +3,7 @@ // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -21,10 +21,6 @@ #include #include -// supress noise -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif #include #include diff --git a/src/thirdparty/boost_lib/boost/serialization/export.hpp b/src/thirdparty/boost_lib/boost/serialization/export.hpp index 6b29556aa..99354782a 100644 --- a/src/thirdparty/boost_lib/boost/serialization/export.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/export.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_EXPORT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -103,14 +103,14 @@ ptr_serialization_support::instantiate() { export_impl::enable_save( #if ! defined(__BORLANDC__) - BOOST_DEDUCED_TYPENAME + typename #endif Archive::is_saving() ); export_impl::enable_load( #if ! defined(__BORLANDC__) - BOOST_DEDUCED_TYPENAME + typename #endif Archive::is_loading() ); diff --git a/src/thirdparty/boost_lib/boost/serialization/extended_type_info.hpp b/src/thirdparty/boost_lib/boost/serialization/extended_type_info.hpp index a4b4b6931..d4b57afa6 100644 --- a/src/thirdparty/boost_lib/boost/serialization/extended_type_info.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/extended_type_info.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/extended_type_info_no_rtti.hpp b/src/thirdparty/boost_lib/boost/serialization/extended_type_info_no_rtti.hpp index 025b3f696..62b247381 100644 --- a/src/thirdparty/boost_lib/boost/serialization/extended_type_info_no_rtti.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/extended_type_info_no_rtti.hpp @@ -3,7 +3,7 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -89,7 +89,7 @@ class extended_type_info_no_rtti : }; static const char * invoke(){ typedef - BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + typename boost::mpl::if_c< tf, defined, undefined @@ -130,15 +130,15 @@ class extended_type_info_no_rtti : va_start(ap, count); switch(count){ case 0: - return factory::type, 0>(ap); + return factory::type, 0>(ap); case 1: - return factory::type, 1>(ap); + return factory::type, 1>(ap); case 2: - return factory::type, 2>(ap); + return factory::type, 2>(ap); case 3: - return factory::type, 3>(ap); + return factory::type, 3>(ap); case 4: - return factory::type, 4>(ap); + return factory::type, 4>(ap); default: BOOST_ASSERT(false); // too many arguments // throw exception here? @@ -167,7 +167,7 @@ class extended_type_info_no_rtti : namespace serialization { template struct extended_type_info_impl { - typedef BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::extended_type_info_no_rtti< T > type; }; } // namespace serialization diff --git a/src/thirdparty/boost_lib/boost/serialization/extended_type_info_typeid.hpp b/src/thirdparty/boost_lib/boost/serialization/extended_type_info_typeid.hpp index 9f09587d6..6a003be1a 100644 --- a/src/thirdparty/boost_lib/boost/serialization/extended_type_info_typeid.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/extended_type_info_typeid.hpp @@ -3,7 +3,7 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -114,15 +114,15 @@ class extended_type_info_typeid : va_start(ap, count); switch(count){ case 0: - return factory::type, 0>(ap); + return factory::type, 0>(ap); case 1: - return factory::type, 1>(ap); + return factory::type, 1>(ap); case 2: - return factory::type, 2>(ap); + return factory::type, 2>(ap); case 3: - return factory::type, 3>(ap); + return factory::type, 3>(ap); case 4: - return factory::type, 4>(ap); + return factory::type, 4>(ap); default: BOOST_ASSERT(false); // too many arguments // throw exception here? @@ -150,7 +150,7 @@ class extended_type_info_typeid : namespace serialization { template struct extended_type_info_impl { - typedef BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::extended_type_info_typeid< T > type; }; } // namespace serialization diff --git a/src/thirdparty/boost_lib/boost/serialization/factory.hpp b/src/thirdparty/boost_lib/boost/serialization/factory.hpp index a25bf204f..b601af626 100644 --- a/src/thirdparty/boost_lib/boost/serialization/factory.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/factory.hpp @@ -3,7 +3,7 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/force_include.hpp b/src/thirdparty/boost_lib/boost/serialization/force_include.hpp index 5578ee81d..468be37fe 100644 --- a/src/thirdparty/boost_lib/boost/serialization/force_include.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/force_include.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/forward_list.hpp b/src/thirdparty/boost_lib/boost/serialization/forward_list.hpp new file mode 100644 index 000000000..6efa87004 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/forward_list.hpp @@ -0,0 +1,102 @@ +#ifndef BOOST_SERIALIZATION_FORWARD_LIST_HPP +#define BOOST_SERIALIZATION_FORWARD_LIST_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// forward_list.hpp + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include // size_t +#include +#include // distance + +#include // msvc 6.0 needs this for warning suppression +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::size_t; +} // namespace std +#endif + +#include +#include +#include +#include + +namespace boost { +namespace serialization { + +template +inline void save( + Archive & ar, + const std::forward_list &t, + const unsigned int file_version +){ + const collection_size_type count(std::distance(t.cbegin(), t.cend())); + boost::serialization::stl::save_collection< + Archive, + std::forward_list + >(ar, t, count); +} + +template +inline void load( + Archive & ar, + std::forward_list &t, + const unsigned int file_version +){ + t.clear(); + // retrieve number of elements + collection_size_type count; + ar >> BOOST_SERIALIZATION_NVP(count); + if(collection_size_type(0) == count) + return; + item_version_type item_version(0); + const boost::archive::library_version_type library_version( + ar.get_library_version() + ); + if(boost::archive::library_version_type(3) < library_version){ + ar >> BOOST_SERIALIZATION_NVP(item_version); + } + boost::serialization::detail::stack_construct u(ar, item_version); + ar >> boost::serialization::make_nvp("item", u.reference()); + t.push_front(u.reference()); + typename std::forward_list::iterator last; + last = t.begin(); + while(--count > 0){ + boost::serialization::detail::stack_construct + u(ar, file_version); + ar >> boost::serialization::make_nvp("item", u.reference()); + last = t.insert_after(last, u.reference()); + ar.reset_object_address(& (*last), & u.reference()); + } +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template +inline void serialize( + Archive & ar, + std::forward_list &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // serialization +} // namespace boost + +#include + +BOOST_SERIALIZATION_COLLECTION_TRAITS(std::forward_list) + +#endif // BOOST_SERIALIZATION_FORWARD_LIST_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/hash_collections_load_imp.hpp b/src/thirdparty/boost_lib/boost/serialization/hash_collections_load_imp.hpp index c064c9f27..de85fd3fd 100644 --- a/src/thirdparty/boost_lib/boost/serialization/hash_collections_load_imp.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/hash_collections_load_imp.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once # pragma warning (disable : 4786) // too long name, harmless warning #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/hash_collections_save_imp.hpp b/src/thirdparty/boost_lib/boost/serialization/hash_collections_save_imp.hpp index 8d1fecec5..65dfe83f1 100644 --- a/src/thirdparty/boost_lib/boost/serialization/hash_collections_save_imp.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/hash_collections_save_imp.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -39,7 +39,7 @@ inline void save_hash_collection(Archive & ar, const Container &s) collection_size_type count(s.size()); const collection_size_type bucket_count(s.bucket_count()); const item_version_type item_version( - version::value + version::value ); #if 0 @@ -76,14 +76,14 @@ inline void save_hash_collection(Archive & ar, const Container &s) ar << BOOST_SERIALIZATION_NVP(item_version); #endif - BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin(); + typename Container::const_iterator it = s.begin(); while(count-- > 0){ // note borland emits a no-op without the explicit namespace boost::serialization::save_construct_data_adl( ar, &(*it), boost::serialization::version< - BOOST_DEDUCED_TYPENAME Container::value_type + typename Container::value_type >::value ); ar << boost::serialization::make_nvp("item", *it++); diff --git a/src/thirdparty/boost_lib/boost/serialization/hash_map.hpp b/src/thirdparty/boost_lib/boost/serialization/hash_map.hpp index f5327388a..615ace8d8 100644 --- a/src/thirdparty/boost_lib/boost/serialization/hash_map.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/hash_map.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_HASH_MAP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -40,11 +40,11 @@ struct archive_input_hash_map Container &s, const unsigned int v ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - std::pair result = + std::pair result = s.insert(t.reference()); // note: the following presumes that the map::value_type was NOT tracked // in the archive. This is the usual case, but here there is no way @@ -67,11 +67,11 @@ struct archive_input_hash_multimap Container &s, const unsigned int v ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - BOOST_DEDUCED_TYPENAME Container::const_iterator result + typename Container::const_iterator result = s.insert(t.reference()); // note: the following presumes that the map::value_type was NOT tracked // in the archive. This is the usual case, but here there is no way diff --git a/src/thirdparty/boost_lib/boost/serialization/hash_set.hpp b/src/thirdparty/boost_lib/boost/serialization/hash_set.hpp index 916c2dd14..6275e0309 100644 --- a/src/thirdparty/boost_lib/boost/serialization/hash_set.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/hash_set.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_HASH_SET_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -38,11 +38,11 @@ struct archive_input_hash_set Container &s, const unsigned int v ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - std::pair result = + std::pair result = s.insert(t.reference()); if(result.second) ar.reset_object_address(& (* result.first), & t.reference()); @@ -58,11 +58,11 @@ struct archive_input_hash_multiset Container &s, const unsigned int v ){ - typedef BOOST_DEDUCED_TYPENAME Container::value_type type; + typedef typename Container::value_type type; detail::stack_construct t(ar, v); // borland fails silently w/o full namespace ar >> boost::serialization::make_nvp("item", t.reference()); - BOOST_DEDUCED_TYPENAME Container::const_iterator result + typename Container::const_iterator result = s.insert(t.reference()); ar.reset_object_address(& (* result), & t.reference()); } diff --git a/src/thirdparty/boost_lib/boost/serialization/is_bitwise_serializable.hpp b/src/thirdparty/boost_lib/boost/serialization/is_bitwise_serializable.hpp index 34eec40ec..dac597ec2 100644 --- a/src/thirdparty/boost_lib/boost/serialization/is_bitwise_serializable.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/is_bitwise_serializable.hpp @@ -17,7 +17,7 @@ #define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/level.hpp b/src/thirdparty/boost_lib/boost/serialization/level.hpp index ce507b228..b037f7ebc 100644 --- a/src/thirdparty/boost_lib/boost/serialization/level.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/level.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_LEVEL_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -29,7 +29,6 @@ #include #include #include -#include #include @@ -43,26 +42,26 @@ template struct implementation_level_impl { template struct traits_class_level { - typedef BOOST_DEDUCED_TYPENAME U::level type; + typedef typename U::level type; }; typedef mpl::integral_c_tag tag; // note: at least one compiler complained w/o the full qualification // on basic traits below typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived, traits_class_level< T >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_fundamental< T >, mpl::int_, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_class< T >, mpl::int_, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_array< T >, #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) mpl::int_, @@ -70,7 +69,7 @@ struct implementation_level_impl { mpl::int_, #endif //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_enum< T >, //#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560)) // mpl::int_, @@ -94,7 +93,7 @@ struct implementation_level : { }; -template +template inline bool operator>=(implementation_level< T > t, enum level_type l) { return t.value >= (int)l; diff --git a/src/thirdparty/boost_lib/boost/serialization/level_enum.hpp b/src/thirdparty/boost_lib/boost/serialization/level_enum.hpp index 11bd17f67..baf64e04f 100644 --- a/src/thirdparty/boost_lib/boost/serialization/level_enum.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/level_enum.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_LEVEL_ENUM_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/list.hpp b/src/thirdparty/boost_lib/boost/serialization/list.hpp index 469bb230e..63d3b472b 100644 --- a/src/thirdparty/boost_lib/boost/serialization/list.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/list.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_LIST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/map.hpp b/src/thirdparty/boost_lib/boost/serialization/map.hpp index 624290df1..11a3d6bbc 100644 --- a/src/thirdparty/boost_lib/boost/serialization/map.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/map.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_MAP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/nvp.hpp b/src/thirdparty/boost_lib/boost/serialization/nvp.hpp index 2d7f4edd0..f33707c30 100644 --- a/src/thirdparty/boost_lib/boost/serialization/nvp.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/nvp.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_NVP_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -20,10 +20,6 @@ #include #include -// supress noise -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif #include #include @@ -104,7 +100,6 @@ nvp< T > make_nvp(const char * name, T & t){ // Partial Template Specialization and doing so would mean that wrappers // wouldn't be treated the same on different platforms. This would // break archive portability. Leave this here as reminder not to use it !!! -#if 0 // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct implementation_level > @@ -123,7 +118,6 @@ struct tracking_level > BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value); }; -#endif } // seralization } // boost diff --git a/src/thirdparty/boost_lib/boost/serialization/optional.hpp b/src/thirdparty/boost_lib/boost/serialization/optional.hpp index 929fa0749..4024cf5e6 100644 --- a/src/thirdparty/boost_lib/boost/serialization/optional.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/optional.hpp @@ -10,7 +10,7 @@ #ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_ #define BOOST_SERIALIZATION_OPTIONAL_HPP_ -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -90,37 +90,6 @@ void serialize( boost::serialization::split_free(ar, t, version); } -// the following would be slightly more efficient. But it -// would mean that archives created with programs that support -// TPS wouldn't be readable by programs that don't support TPS. -// Hence we decline to support this otherwise convenient optimization. -//#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#if 0 - -template -struct implementation_level > -{ - typedef mpl::integral_c_tag tag; - typedef mpl::int_ type; - BOOST_STATIC_CONSTANT( - int , - value = boost::serialization::implementation_level::type::value - ); -}; - -template -struct tracking_level > -{ - typedef mpl::integral_c_tag tag; - typedef mpl::int_ type; - BOOST_STATIC_CONSTANT( - int , - value = boost::serialization::tracking_level::type::value - ); -}; - -#endif - } // serialization } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/serialization/pfto.hpp b/src/thirdparty/boost_lib/boost/serialization/pfto.hpp index 8d984630e..0370d2831 100644 --- a/src/thirdparty/boost_lib/boost/serialization/pfto.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/pfto.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_PFTO_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/priority_queue.hpp b/src/thirdparty/boost_lib/boost/serialization/priority_queue.hpp new file mode 100644 index 000000000..3ba63a5b2 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/priority_queue.hpp @@ -0,0 +1,74 @@ +#ifndef BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP +#define BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// priority_queue.hpp + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include +#include + +// function specializations must be defined in the appropriate +// namespace - boost::serialization +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +#define STD _STLP_STD +#else +#define STD std +#endif + +namespace boost { +namespace serialization { +namespace detail{ + +template +struct priority_queue_save : public STD::priority_queue { + template + void operator()(Archive & ar, const unsigned int file_version) const { + save(ar, STD::priority_queue::c, file_version); + } +}; +template +struct priority_queue_load : public STD::priority_queue { + template + void operator()(Archive & ar, const unsigned int file_version) { + load(ar, STD::priority_queue::c, file_version); + } +}; + +} // detail + +template +inline void serialize( + Archive & ar, + std::priority_queue< T, Container, Compare> & t, + const unsigned int file_version +){ + typedef typename mpl::eval_if< + typename Archive::is_saving, + mpl::identity >, + mpl::identity > + >::type typex; + static_cast(t)(ar, file_version); +} + +} // namespace serialization +} // namespace boost + +#include + +BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::priority_queue) + +#undef STD + +#endif // BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/queue.hpp b/src/thirdparty/boost_lib/boost/serialization/queue.hpp new file mode 100644 index 000000000..58e1ee92f --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/queue.hpp @@ -0,0 +1,74 @@ +#ifndef BOOST_SERIALIZATION_QUEUE_HPP +#define BOOST_SERIALIZATION_QUEUE_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// queue.hpp + +// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include +#include + +// function specializations must be defined in the appropriate +// namespace - boost::serialization +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +#define STD _STLP_STD +#else +#define STD std +#endif + +namespace boost { +namespace serialization { +namespace detail { + +template +struct queue_save : public STD::queue { + template + void operator()(Archive & ar, const unsigned int file_version) const { + save(ar, STD::queue::c, file_version); + } +}; +template +struct queue_load : public STD::queue { + template + void operator()(Archive & ar, const unsigned int file_version) { + load(ar, STD::queue::c, file_version); + } +}; + +} // detail + +template +inline void serialize( + Archive & ar, + std::queue< T, C> & t, + const unsigned int file_version +){ + typedef typename mpl::eval_if< + typename Archive::is_saving, + mpl::identity >, + mpl::identity > + >::type typex; + static_cast(t)(ar, file_version); +} + +} // namespace serialization +} // namespace boost + +#include + +BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::queue) + +#undef STD + +#endif // BOOST_SERIALIZATION_QUEUE_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/scoped_ptr.hpp b/src/thirdparty/boost_lib/boost/serialization/scoped_ptr.hpp index ef522d8ce..0d11f8436 100644 --- a/src/thirdparty/boost_lib/boost/serialization/scoped_ptr.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/scoped_ptr.hpp @@ -1,7 +1,7 @@ #ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30 #define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30 -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/serialization.hpp b/src/thirdparty/boost_lib/boost/serialization/serialization.hpp index f17e8dd80..8462b594c 100644 --- a/src/thirdparty/boost_lib/boost/serialization/serialization.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/serialization.hpp @@ -2,11 +2,11 @@ #define BOOST_SERIALIZATION_SERIALIZATION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif -#if defined(_MSC_VER) && (_MSC_VER >= 1310) +#if defined(_MSC_VER) # pragma warning (disable : 4675) // suppress ADL warning #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/set.hpp b/src/thirdparty/boost_lib/boost/serialization/set.hpp index 4bb69abb9..6882fb040 100644 --- a/src/thirdparty/boost_lib/boost/serialization/set.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/set.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SET_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/shared_ptr.hpp b/src/thirdparty/boost_lib/boost/serialization/shared_ptr.hpp index 37f95e35a..f59567898 100644 --- a/src/thirdparty/boost_lib/boost/serialization/shared_ptr.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/shared_ptr.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SHARED_PTR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -25,13 +25,14 @@ #include #include +#include #include #include #include #include /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// shared_ptr serialization traits +// boost:: shared_ptr serialization traits // version 1 to distinguish from boost 1.32 version. Note: we can only do this // for a template when the compiler supports partial template specialization @@ -42,7 +43,7 @@ struct version< ::boost::shared_ptr< T > > { typedef mpl::integral_c_tag tag; #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) - typedef BOOST_DEDUCED_TYPENAME mpl::int_<1> type; + typedef typename mpl::int_<1> type; #else typedef mpl::int_<1> type; #endif @@ -57,7 +58,7 @@ struct tracking_level< ::boost::shared_ptr< T > > { typedef mpl::integral_c_tag tag; #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) - typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type; + typedef typename mpl::int_< ::boost::serialization::track_never> type; #else typedef mpl::int_< ::boost::serialization::track_never> type; #endif @@ -91,7 +92,7 @@ struct null_deleter { }; /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// serialization for shared_ptr +// serialization for boost::shared_ptr template inline void save( @@ -120,9 +121,6 @@ inline void load( BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); T* r; if(file_version < 1){ - //ar.register_type(static_cast< - // boost_132::detail::sp_counted_base_impl > * - //>(NULL)); ar.register_type(static_cast< boost_132::detail::sp_counted_base_impl * >(NULL)); @@ -130,15 +128,22 @@ inline void load( ar >> boost::serialization::make_nvp("px", sp.px); ar >> boost::serialization::make_nvp("pn", sp.pn); // got to keep the sps around so the sp.pns don't disappear - ar.append(sp); + boost::serialization::shared_ptr_helper & h = + ar.template get_helper< + shared_ptr_helper + >(); + h.append(sp); r = sp.get(); } else{ ar >> boost::serialization::make_nvp("px", r); } - ar.reset(t,r); + shared_ptr_helper & h = + ar.template get_helper< + boost::serialization::shared_ptr_helper + >(); + h.reset(t,r); } - #else template inline void load( @@ -152,7 +157,11 @@ inline void load( BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); T* r; ar >> boost::serialization::make_nvp("px", r); - ar.reset(t,r); + boost::serialization::shared_ptr_helper & h = + ar.template get_helper< + shared_ptr_helper + >(); + h.reset(t,r); } #endif @@ -174,4 +183,97 @@ inline void serialize( } // namespace serialization } // namespace boost +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// std::shared_ptr serialization traits +// version 1 to distinguish from boost 1.32 version. Note: we can only do this +// for a template when the compiler supports partial template specialization + +#ifndef BOOST_NO_CXX11_SMART_PTR +#include + +// note: we presume that any compiler/library which supports C++11 +// std::pointers also supports template partial specialization +// trap here if such presumption were to turn out to wrong!!! +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_STATIC_ASSERT(false); +#endif + +namespace boost { +namespace serialization{ + template + struct version< ::std::shared_ptr< T > > { + typedef mpl::integral_c_tag tag; + typedef mpl::int_<1> type; + BOOST_STATIC_CONSTANT(int, value = type::value); + }; + // don't track shared pointers + template + struct tracking_level< ::std::shared_ptr< T > > { + typedef mpl::integral_c_tag tag; + typedef mpl::int_< ::boost::serialization::track_never> type; + BOOST_STATIC_CONSTANT(int, value = type::value); + }; +}} +// the following just keeps older programs from breaking +#define BOOST_SERIALIZATION_SHARED_PTR(T) + +namespace boost { +namespace serialization{ + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// serialization for std::shared_ptr + +template +inline void save( + Archive & ar, + const std::shared_ptr< T > &t, + const unsigned int /* file_version */ +){ + // The most common cause of trapping here would be serializing + // something like shared_ptr. This occurs because int + // is never tracked by default. Wrap int in a trackable type + BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); + const T * t_ptr = t.get(); + ar << boost::serialization::make_nvp("px", t_ptr); +} + +template +inline void load( + Archive & ar, + std::shared_ptr< T > &t, + const unsigned int /*file_version*/ +){ + // The most common cause of trapping here would be serializing + // something like shared_ptr. This occurs because int + // is never tracked by default. Wrap int in a trackable type + BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never)); + T* r; + ar >> boost::serialization::make_nvp("px", r); + boost::serialization::shared_ptr_helper & h = + ar.template get_helper< + shared_ptr_helper + >(); + h.reset(t,r); +} + +template +inline void serialize( + Archive & ar, + std::shared_ptr< T > &t, + const unsigned int file_version +){ + // correct shared_ptr serialization depends upon object tracking + // being used. + BOOST_STATIC_ASSERT( + boost::serialization::tracking_level< T >::value + != boost::serialization::track_never + ); + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_NO_CXX11_SMART_PTR + #endif // BOOST_SERIALIZATION_SHARED_PTR_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/shared_ptr_132.hpp b/src/thirdparty/boost_lib/boost/serialization/shared_ptr_132.hpp index 9bcefe099..ea02abdb8 100644 --- a/src/thirdparty/boost_lib/boost/serialization/shared_ptr_132.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/shared_ptr_132.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SHARED_PTR_132_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/shared_ptr_helper.hpp b/src/thirdparty/boost_lib/boost/serialization/shared_ptr_helper.hpp new file mode 100644 index 000000000..9dace87c1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/shared_ptr_helper.hpp @@ -0,0 +1,212 @@ +#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP +#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// shared_ptr_helper.hpp: serialization for boost shared pointern + +// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include +#include +#include +#include // NULL + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include // must be the last headern + +namespace boost_132 { + template class shared_ptr; +} +namespace boost { +namespace serialization { + +class extended_type_info; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +template class SPT > +void load( + Archive & ar, + SPT< class U > &t, + const unsigned int file_version +); +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// a common class for holding various types of shared pointers + +template class SPT> +class shared_ptr_helper { + typedef std::map< + const void *, // address of object + SPT // address shared ptr to single instance + > object_shared_pointer_map; + + // list of shared_pointers create accessable by raw pointer. This + // is used to "match up" shared pointers loaded at different + // points in the archive. Note, we delay construction until + // it is actually used since this is by default included as + // a "mix-in" even if shared_ptr isn't used. + object_shared_pointer_map * m_o_sp; + + struct null_deleter { + void operator()(void const *) const {} + }; + +#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) || defined(BOOST_MSVC) +public: +#else + template + friend void boost::serialization::load( + Archive & ar, + SPT< U > &t, + const unsigned int file_version + ); +#endif + + #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP + // list of loaded pointers. This is used to be sure that the pointers + // stay around long enough to be "matched" with other pointers loaded + // by the same archive. These are created with a "null_deleter" so that + // when this list is destroyed - the underlaying raw pointers are not + // destroyed. This has to be done because the pointers are also held by + // new system which is disjoint from this set. This is implemented + // by a change in load_construct_data below. It makes this file suitable + // only for loading pointers into a 1.33 or later boost system. + std::list > * m_pointers_132; + BOOST_ARCHIVE_DECL(void) + append(const boost_132::shared_ptr & t){ + if(NULL == m_pointers_132) + m_pointers_132 = new std::list >; + m_pointers_132->push_back(t); + } + #endif + + struct non_polymorphic { + template + static const boost::serialization::extended_type_info * + get_object_type(U & ){ + return & boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< U >::type + >::get_const_instance(); + } + }; + struct polymorphic { + template + static const boost::serialization::extended_type_info * + get_object_type(U & u){ + return boost::serialization::singleton< + typename + boost::serialization::type_info_implementation< U >::type + >::get_const_instance().get_derived_extended_type_info(u); + } + }; + +public: + template + void reset(SPT< T > & s, T * t){ + if(NULL == t){ + s.reset(); + return; + } + const boost::serialization::extended_type_info * this_type + = & boost::serialization::type_info_implementation< T >::type + ::get_const_instance(); + + // get pointer to the most derived object's eti. This is effectively + // the object type identifer + typedef typename mpl::if_< + is_polymorphic< T >, + polymorphic, + non_polymorphic + >::type type; + + const boost::serialization::extended_type_info * true_type + = type::get_object_type(*t); + + // note:if this exception is thrown, be sure that derived pointern + // is either registered or exported. + if(NULL == true_type) + boost::serialization::throw_exception( + boost::archive::archive_exception( + boost::archive::archive_exception::unregistered_class, + this_type->get_debug_info() + ) + ); + // get void pointer to the most derived type + // this uniquely identifies the object referred to + // oid = "object identifier" + const void * oid = void_downcast( + *true_type, + *this_type, + t + ); + if(NULL == oid) + boost::serialization::throw_exception( + boost::archive::archive_exception( + boost::archive::archive_exception::unregistered_cast, + true_type->get_debug_info(), + this_type->get_debug_info() + ) + ); + + // make tracking array if necessary + if(NULL == m_o_sp) + m_o_sp = new object_shared_pointer_map; + + typename object_shared_pointer_map::iterator i = m_o_sp->find(oid); + + // if it's a new object + if(i == m_o_sp->end()){ + s.reset(t); + std::pair result; + result = m_o_sp->insert(std::make_pair(oid, s)); + BOOST_ASSERT(result.second); + } + // if the object has already been seen + else{ + s = SPT(i->second, t); + } + } + + shared_ptr_helper() : + m_o_sp(NULL) + #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP + , m_pointers_132(NULL) + #endif + {} + virtual ~shared_ptr_helper(){ + if(NULL != m_o_sp) + delete m_o_sp; + #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP + if(NULL != m_pointers_132) + delete m_pointers_132; + #endif + } +}; + +} // namespace serialization +} // namespace boost + +#include // pops abi_suffix.hpp pragmas + +#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/singleton.hpp b/src/thirdparty/boost_lib/boost/serialization/singleton.hpp index f521590e1..546118c86 100644 --- a/src/thirdparty/boost_lib/boost/serialization/singleton.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/singleton.hpp @@ -30,7 +30,7 @@ // // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/slist.hpp b/src/thirdparty/boost_lib/boost/serialization/slist.hpp index f369fcaf2..4072076fa 100644 --- a/src/thirdparty/boost_lib/boost/serialization/slist.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/slist.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SLIST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -70,7 +70,7 @@ inline void load( boost::serialization::detail::stack_construct u(ar, item_version); ar >> boost::serialization::make_nvp("item", u.reference()); t.push_front(u.reference()); - BOOST_DEDUCED_TYPENAME BOOST_STD_EXTENSION_NAMESPACE::slist::iterator last; + typename BOOST_STD_EXTENSION_NAMESPACE::slist::iterator last; last = t.begin(); while(--count > 0){ boost::serialization::detail::stack_construct diff --git a/src/thirdparty/boost_lib/boost/serialization/smart_cast.hpp b/src/thirdparty/boost_lib/boost/serialization/smart_cast.hpp index 977e8edbf..02edb4be0 100644 --- a/src/thirdparty/boost_lib/boost/serialization/smart_cast.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/smart_cast.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SMART_CAST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -95,15 +95,15 @@ namespace smart_cast_impl { // cross casting will be selected this will work but will // not be the most efficient method. This will conflict with // the original smart_cast motivation. - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME mpl::and_< + typedef typename mpl::eval_if< + typename mpl::and_< mpl::not_::type, + typename remove_reference< T >::type, U > >, mpl::not_::type + typename remove_reference< T >::type > > >, // borland chokes w/o full qualification here @@ -131,7 +131,7 @@ namespace smart_cast_impl { mpl::identity >::type::cast(u); #else - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< boost::is_polymorphic, mpl::identity, mpl::identity @@ -170,7 +170,7 @@ namespace smart_cast_impl { template static T cast(U * u){ // if we're in debug mode - #if ! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) + #if 0 //! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) // do a checked dynamic cast return cross::cast(u); #else @@ -180,15 +180,15 @@ namespace smart_cast_impl { // not be the most efficient method. This will conflict with // the original smart_cast motivation. typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME mpl::and_< + typename mpl::eval_if< + typename mpl::and_< mpl::not_::type, + typename remove_pointer< T >::type, U > >, mpl::not_::type + typename remove_pointer< T >::type > > >, // borland chokes w/o full qualification here @@ -226,7 +226,7 @@ namespace smart_cast_impl { mpl::identity >::type::cast(u); #else - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< boost::is_polymorphic, mpl::identity, mpl::identity @@ -267,8 +267,8 @@ namespace smart_cast_impl { template T smart_cast(U u) { typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME mpl::or_< + typename mpl::eval_if< + typename mpl::or_< boost::is_same, boost::is_same, boost::is_same, @@ -276,10 +276,10 @@ T smart_cast(U u) { >, mpl::identity >, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity >, // else - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity >, // else mpl::identity diff --git a/src/thirdparty/boost_lib/boost/serialization/split_free.hpp b/src/thirdparty/boost_lib/boost/serialization/split_free.hpp index 9dbcd2fd1..85e2f590f 100644 --- a/src/thirdparty/boost_lib/boost/serialization/split_free.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/split_free.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SPLIT_FREE_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -66,8 +66,8 @@ inline void split_free( T & t, const unsigned int file_version ){ - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME Archive::is_saving, + typedef typename mpl::eval_if< + typename Archive::is_saving, mpl::identity >, mpl::identity > >::type typex; diff --git a/src/thirdparty/boost_lib/boost/serialization/split_member.hpp b/src/thirdparty/boost_lib/boost/serialization/split_member.hpp index 69879450d..5f3252055 100644 --- a/src/thirdparty/boost_lib/boost/serialization/split_member.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/split_member.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -61,8 +61,8 @@ template inline void split_member( Archive & ar, T & t, const unsigned int file_version ){ - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< - BOOST_DEDUCED_TYPENAME Archive::is_saving, + typedef typename mpl::eval_if< + typename Archive::is_saving, mpl::identity >, mpl::identity > >::type typex; diff --git a/src/thirdparty/boost_lib/boost/serialization/stack.hpp b/src/thirdparty/boost_lib/boost/serialization/stack.hpp new file mode 100644 index 000000000..aea3ba8e0 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/stack.hpp @@ -0,0 +1,74 @@ +#ifndef BOOST_SERIALIZATION_STACK_HPP +#define BOOST_SERIALIZATION_STACK_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// stack.hpp + +// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include +#include + +// function specializations must be defined in the appropriate +// namespace - boost::serialization +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +#define STD _STLP_STD +#else +#define STD std +#endif + +namespace boost { +namespace serialization { +namespace detail{ + +template +struct stack_save : public STD::stack { + template + void operator()(Archive & ar, const unsigned int file_version) const { + save(ar, STD::stack::c, file_version); + } +}; +template +struct stack_load : public STD::stack { + template + void operator()(Archive & ar, const unsigned int file_version) { + load(ar, STD::stack::c, file_version); + } +}; + +} // detail + +template +inline void serialize( + Archive & ar, + std::stack< T, C> & t, + const unsigned int file_version +){ + typedef typename mpl::eval_if< + typename Archive::is_saving, + mpl::identity >, + mpl::identity > + >::type typex; + static_cast(t)(ar, file_version); +} + +} // namespace serialization +} // namespace boost + +#include + +BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::stack) + +#undef STD + +#endif // BOOST_SERIALIZATION_DEQUE_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/state_saver.hpp b/src/thirdparty/boost_lib/boost/serialization/state_saver.hpp index 69cbe3e21..6e6f98578 100644 --- a/src/thirdparty/boost_lib/boost/serialization/state_saver.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/state_saver.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_STATE_SAVER_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -77,7 +77,7 @@ class state_saver : private boost::noncopyable ~state_saver() { #ifndef BOOST_NO_EXCEPTIONS - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + typedef typename mpl::eval_if< has_nothrow_copy< T >, mpl::identity, mpl::identity diff --git a/src/thirdparty/boost_lib/boost/serialization/static_warning.hpp b/src/thirdparty/boost_lib/boost/serialization/static_warning.hpp index b41791ad8..d2f23d36d 100644 --- a/src/thirdparty/boost_lib/boost/serialization/static_warning.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/static_warning.hpp @@ -5,7 +5,7 @@ // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -72,6 +72,7 @@ #include #include #include +#include namespace boost { namespace serialization { @@ -101,8 +102,7 @@ struct BOOST_SERIALIZATION_SS {}; #define BOOST_SERIALIZATION_BSW(B, L) \ typedef boost::serialization::BOOST_SERIALIZATION_SS< \ sizeof( boost::serialization::static_warning_test< B, L > ) \ - > BOOST_JOIN(STATIC_WARNING_LINE, L); - + > BOOST_JOIN(STATIC_WARNING_LINE, L) BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE; #define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__) #endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/string.hpp b/src/thirdparty/boost_lib/boost/serialization/string.hpp index 36d15942a..d63df768a 100644 --- a/src/thirdparty/boost_lib/boost/serialization/string.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/string.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_STRING_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/strong_typedef.hpp b/src/thirdparty/boost_lib/boost/serialization/strong_typedef.hpp index c6308c282..54a51626a 100644 --- a/src/thirdparty/boost_lib/boost/serialization/strong_typedef.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/strong_typedef.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/throw_exception.hpp b/src/thirdparty/boost_lib/boost/serialization/throw_exception.hpp index ed7d8109f..b67618adc 100644 --- a/src/thirdparty/boost_lib/boost/serialization/throw_exception.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/throw_exception.hpp @@ -3,7 +3,7 @@ // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/tracking.hpp b/src/thirdparty/boost_lib/boost/serialization/tracking.hpp index fadcbd09c..d5c79b840 100644 --- a/src/thirdparty/boost_lib/boost/serialization/tracking.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/tracking.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_TRACKING_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -41,24 +41,24 @@ template struct tracking_level_impl { template struct traits_class_tracking { - typedef BOOST_DEDUCED_TYPENAME U::tracking type; + typedef typename U::tracking type; }; typedef mpl::integral_c_tag tag; // note: at least one compiler complained w/o the full qualification // on basic traits below typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived, traits_class_tracking< T >, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_pointer< T >, // pointers are not tracked by default mpl::int_, //else - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< // for primitives - BOOST_DEDUCED_TYPENAME mpl::equal_to< + typename mpl::equal_to< implementation_level< T >, mpl::int_ >, diff --git a/src/thirdparty/boost_lib/boost/serialization/tracking_enum.hpp b/src/thirdparty/boost_lib/boost/serialization/tracking_enum.hpp index e4e4e2135..278051e1b 100644 --- a/src/thirdparty/boost_lib/boost/serialization/tracking_enum.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/tracking_enum.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_TRACKING_ENUM_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/traits.hpp b/src/thirdparty/boost_lib/boost/serialization/traits.hpp index da800098a..d338b1b12 100644 --- a/src/thirdparty/boost_lib/boost/serialization/traits.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/traits.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_TRAITS_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -52,9 +52,9 @@ template< struct traits : public basic_traits { BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info); BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable); - typedef BOOST_DEDUCED_TYPENAME mpl::int_ level; - typedef BOOST_DEDUCED_TYPENAME mpl::int_ tracking; - typedef BOOST_DEDUCED_TYPENAME mpl::int_ version; + typedef typename mpl::int_ level; + typedef typename mpl::int_ tracking; + typedef typename mpl::int_ version; typedef ETII type_info_implementation; typedef Wrapper is_wrapper; }; diff --git a/src/thirdparty/boost_lib/boost/serialization/type_info_implementation.hpp b/src/thirdparty/boost_lib/boost/serialization/type_info_implementation.hpp index 00eb152d8..2c033fc87 100644 --- a/src/thirdparty/boost_lib/boost/serialization/type_info_implementation.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/type_info_implementation.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -35,17 +35,17 @@ template struct type_info_implementation { template struct traits_class_typeinfo_implementation { - typedef BOOST_DEDUCED_TYPENAME U::type_info_implementation::type type; + typedef typename U::type_info_implementation::type type; }; // note: at least one compiler complained w/o the full qualification // on basic traits below typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived, traits_class_typeinfo_implementation< T >, //else mpl::identity< - BOOST_DEDUCED_TYPENAME extended_type_info_impl< T >::type + typename extended_type_info_impl< T >::type > >::type type; }; diff --git a/src/thirdparty/boost_lib/boost/serialization/unique_ptr.hpp b/src/thirdparty/boost_lib/boost/serialization/unique_ptr.hpp new file mode 100644 index 000000000..ac615b9d1 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/unique_ptr.hpp @@ -0,0 +1,68 @@ +#ifndef BOOST_SERIALIZATION_UNIQUE_PTR_HPP +#define BOOST_SERIALIZATION_UNIQUE_PTR_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// unique_ptr.hpp: + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. +#include +#include +#include + +namespace boost { +namespace serialization { + +///////////////////////////////////////////////////////////// +// implement serialization for unique_ptr< T > +// note: this must be added to the boost namespace in order to +// be called by the library +template +inline void save( + Archive & ar, + const std::unique_ptr< T > &t, + const unsigned int file_version +){ + // only the raw pointer has to be saved + // the ref count is rebuilt automatically on load + const T * const tx = t.get(); + ar << BOOST_SERIALIZATION_NVP(tx); +} + +template +inline void load( + Archive & ar, + std::unique_ptr< T > &t, + const unsigned int file_version +){ + T *tx; + ar >> BOOST_SERIALIZATION_NVP(tx); + // note that the reset automagically maintains the reference count + t.reset(tx); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template +inline void serialize( + Archive & ar, + std::unique_ptr< T > &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + + +#endif // BOOST_SERIALIZATION_UNIQUE_PTR_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/unordered_collections_load_imp.hpp b/src/thirdparty/boost_lib/boost/serialization/unordered_collections_load_imp.hpp new file mode 100644 index 000000000..bf5674134 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/unordered_collections_load_imp.hpp @@ -0,0 +1,74 @@ +#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP +#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +# pragma warning (disable : 4786) // too long name, harmless warning +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// unordered_collections_load_imp.hpp: serialization for loading stl collections + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// (C) Copyright 2014 Jim Bell +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +// helper function templates for serialization of collections + +#include +#include // size_t +#include // msvc 6.0 needs this for warning suppression +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::size_t; +} // namespace std +#endif +#include + +#include +#include +#include +#include +#include +#include + +namespace boost{ +namespace serialization { +namespace stl { + +////////////////////////////////////////////////////////////////////// +// implementation of serialization for STL containers +// +template +inline void load_unordered_collection(Archive & ar, Container &s) +{ + s.clear(); + collection_size_type count; + collection_size_type bucket_count; + boost::serialization::item_version_type item_version(0); + boost::archive::library_version_type library_version( + ar.get_library_version() + ); + // retrieve number of elements + ar >> BOOST_SERIALIZATION_NVP(count); + ar >> BOOST_SERIALIZATION_NVP(bucket_count); + if(boost::archive::library_version_type(3) < library_version){ + ar >> BOOST_SERIALIZATION_NVP(item_version); + } + s.rehash(bucket_count); + InputFunction ifunc; + while(count-- > 0){ + ifunc(ar, s, item_version); + } +} + +} // namespace stl +} // namespace serialization +} // namespace boost + +#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/unordered_collections_save_imp.hpp b/src/thirdparty/boost_lib/boost/serialization/unordered_collections_save_imp.hpp new file mode 100644 index 000000000..56746ebea --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/unordered_collections_save_imp.hpp @@ -0,0 +1,86 @@ +#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP +#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// hash_collections_save_imp.hpp: serialization for stl collections + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// (C) Copyright 2014 Jim Bell +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +// helper function templates for serialization of collections + +#include +#include +#include +#include +#include +#include + +namespace boost{ +namespace serialization { +namespace stl { + +////////////////////////////////////////////////////////////////////// +// implementation of serialization for STL containers +// + +template +inline void save_unordered_collection(Archive & ar, const Container &s) +{ + collection_size_type count(s.size()); + const collection_size_type bucket_count(s.bucket_count()); + const item_version_type item_version( + version::value + ); + + #if 0 + /* should only be necessary to create archives of previous versions + * which is not currently supported. So for now comment this out + */ + boost::archive::library_version_type library_version( + ar.get_library_version() + ); + // retrieve number of elements + ar << BOOST_SERIALIZATION_NVP(count); + ar << BOOST_SERIALIZATION_NVP(bucket_count); + if(boost::archive::library_version_type(3) < library_version){ + // record number of elements + // make sure the target type is registered so we can retrieve + // the version when we load + ar << BOOST_SERIALIZATION_NVP(item_version); + } + #else + ar << BOOST_SERIALIZATION_NVP(count); + ar << BOOST_SERIALIZATION_NVP(bucket_count); + ar << BOOST_SERIALIZATION_NVP(item_version); + #endif + + typename Container::const_iterator it = s.begin(); + while(count-- > 0){ + // note borland emits a no-op without the explicit namespace + boost::serialization::save_construct_data_adl( + ar, + &(*it), + boost::serialization::version< + typename Container::value_type + >::value + ); + ar << boost::serialization::make_nvp("item", *it++); + } +} + +} // namespace stl +} // namespace serialization +} // namespace boost + +#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/unordered_map.hpp b/src/thirdparty/boost_lib/boost/serialization/unordered_map.hpp new file mode 100644 index 000000000..f3959104d --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/unordered_map.hpp @@ -0,0 +1,231 @@ +#ifndef BOOST_SERIALIZATION_UNORDERED_MAP_HPP +#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// serialization/unordered_map.hpp: +// serialization for stl unordered_map templates + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// (C) Copyright 2014 Jim Bell +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include + +#include + +#include +#include +#include +#include + +namespace boost { +namespace serialization { + +namespace stl { + +// map input +template +struct archive_input_unordered_map +{ + inline void operator()( + Archive &ar, + Container &s, + const unsigned int v + ){ + typedef typename Container::value_type type; + detail::stack_construct t(ar, v); + // borland fails silently w/o full namespace + ar >> boost::serialization::make_nvp("item", t.reference()); + std::pair result = + s.insert(t.reference()); + // note: the following presumes that the map::value_type was NOT tracked + // in the archive. This is the usual case, but here there is no way + // to determine that. + if(result.second){ + ar.reset_object_address( + & (result.first->second), + & t.reference().second + ); + } + } +}; + +// multimap input +template +struct archive_input_unordered_multimap +{ + inline void operator()( + Archive &ar, + Container &s, + const unsigned int v + ){ + typedef typename Container::value_type type; + detail::stack_construct t(ar, v); + // borland fails silently w/o full namespace + ar >> boost::serialization::make_nvp("item", t.reference()); + typename Container::const_iterator result + = s.insert(t.reference()); + // note: the following presumes that the map::value_type was NOT tracked + // in the archive. This is the usual case, but here there is no way + // to determine that. + ar.reset_object_address( + & result->second, + & t.reference() + ); + } +}; + +} // stl + +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void save( + Archive & ar, + const std::unordered_map< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::save_unordered_collection< + Archive, + std::unordered_map< + Key, HashFcn, EqualKey, Allocator + > + >(ar, t); +} + +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void load( + Archive & ar, + std::unordered_map< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::load_unordered_collection< + Archive, + std::unordered_map< + Key, HashFcn, EqualKey, Allocator + >, + boost::serialization::stl::archive_input_unordered_map< + Archive, + std::unordered_map< + Key, HashFcn, EqualKey, Allocator + > + > + >(ar, t); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void serialize( + Archive & ar, + std::unordered_map< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +// unordered_multimap +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void save( + Archive & ar, + const std::unordered_multimap< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::save_unordered_collection< + Archive, + std::unordered_multimap< + Key, HashFcn, EqualKey, Allocator + > + >(ar, t); +} + +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void load( + Archive & ar, + std::unordered_multimap< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::load_unordered_collection< + Archive, + std::unordered_multimap< + Key, HashFcn, EqualKey, Allocator + >, + boost::serialization::stl::archive_input_unordered_multimap< + Archive, + std::unordered_multimap< + Key, HashFcn, EqualKey, Allocator + > + > + >(ar, t); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void serialize( + Archive & ar, + std::unordered_multimap< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/unordered_set.hpp b/src/thirdparty/boost_lib/boost/serialization/unordered_set.hpp new file mode 100644 index 000000000..535194fb7 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/serialization/unordered_set.hpp @@ -0,0 +1,216 @@ +#ifndef BOOST_SERIALIZATION_UNORDERED_SET_HPP +#define BOOST_SERIALIZATION_UNORDERED_SET_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// unordered_set.hpp: serialization for stl unordered_set templates + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// (C) Copyright 2014 Jim Bell +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include + +#include + +#include +#include +#include + +namespace boost { +namespace serialization { + +namespace stl { + +// unordered_set input +template +struct archive_input_unordered_set +{ + inline void operator()( + Archive &ar, + Container &s, + const unsigned int v + ){ + typedef typename Container::value_type type; + detail::stack_construct t(ar, v); + // borland fails silently w/o full namespace + ar >> boost::serialization::make_nvp("item", t.reference()); + std::pair result = + s.insert(t.reference()); + if(result.second) + ar.reset_object_address(& (* result.first), & t.reference()); + } +}; + +// unordered_multiset input +template +struct archive_input_unordered_multiset +{ + inline void operator()( + Archive &ar, + Container &s, + const unsigned int v + ){ + typedef typename Container::value_type type; + detail::stack_construct t(ar, v); + // borland fails silently w/o full namespace + ar >> boost::serialization::make_nvp("item", t.reference()); + typename Container::const_iterator result + = s.insert(t.reference()); + ar.reset_object_address(& (* result), & t.reference()); + } +}; + +} // stl + +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void save( + Archive & ar, + const std::unordered_set< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::save_unordered_collection< + Archive, + std::unordered_set< + Key, HashFcn, EqualKey, Allocator + > + >(ar, t); +} + +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void load( + Archive & ar, + std::unordered_set< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::load_unordered_collection< + Archive, + std::unordered_set< + Key, HashFcn, EqualKey, Allocator + >, + boost::serialization::stl::archive_input_unordered_set< + Archive, + std::unordered_set< + Key, HashFcn, EqualKey, Allocator + > + > + >(ar, t); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void serialize( + Archive & ar, + std::unordered_set< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +// unordered_multiset +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void save( + Archive & ar, + const std::unordered_multiset< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::save_unordered_collection< + Archive, + std::unordered_multiset< + Key, HashFcn, EqualKey, Allocator + > + >(ar, t); +} + +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void load( + Archive & ar, + std::unordered_multiset< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int /*file_version*/ +){ + boost::serialization::stl::load_unordered_collection< + Archive, + std::unordered_multiset< + Key, HashFcn, EqualKey, Allocator + >, + boost::serialization::stl::archive_input_unordered_multiset< + Archive, + std::unordered_multiset< + Key, HashFcn, EqualKey, Allocator + > + > + >(ar, t); +} + +// split non-intrusive serialization function member into separate +// non intrusive save/load member functions +template< + class Archive, + class Key, + class HashFcn, + class EqualKey, + class Allocator +> +inline void serialize( + Archive & ar, + std::unordered_multiset< + Key, HashFcn, EqualKey, Allocator + > &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_SERIALIZATION_UNORDERED_SET_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/utility.hpp b/src/thirdparty/boost_lib/boost/serialization/utility.hpp index 3d69abc7b..4867a4a12 100644 --- a/src/thirdparty/boost_lib/boost/serialization/utility.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/utility.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_UTILITY_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -38,7 +38,7 @@ inline void serialize( // note: we remove any const-ness on the first argument. The reason is that // for stl maps, the type saved is pair::type typef; + typedef typename boost::remove_const::type typef; ar & boost::serialization::make_nvp("first", const_cast(p.first)); ar & boost::serialization::make_nvp("second", p.second); } diff --git a/src/thirdparty/boost_lib/boost/serialization/valarray.hpp b/src/thirdparty/boost_lib/boost/serialization/valarray.hpp index 4bf722f4d..d24fda543 100644 --- a/src/thirdparty/boost_lib/boost/serialization/valarray.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/valarray.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_VALARAY_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/variant.hpp b/src/thirdparty/boost_lib/boost/serialization/variant.hpp index 9c8ea9d93..70e395e21 100644 --- a/src/thirdparty/boost_lib/boost/serialization/variant.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/variant.hpp @@ -2,14 +2,10 @@ #define BOOST_SERIALIZATION_VARIANT_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif -#if defined(_MSC_VER) && (_MSC_VER <= 1020) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif - /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // variant.hpp - non-intrusive serialization of variant types // @@ -70,7 +66,7 @@ void save( ){ int which = v.which(); ar << BOOST_SERIALIZATION_NVP(which); - typedef BOOST_DEDUCED_TYPENAME boost::variant::types types; + typedef typename boost::variant::types types; variant_save_visitor visitor(ar); v.apply_visitor(visitor); } @@ -101,14 +97,14 @@ struct variant_impl { // necessary has to copy the value. This wouldn't be necessary // with an implementation that de-serialized to the address of the // aligned storage included in the variant. - typedef BOOST_DEDUCED_TYPENAME mpl::front::type head_type; + typedef typename mpl::front::type head_type; head_type value; ar >> BOOST_SERIALIZATION_NVP(value); v = value; ar.reset_object_address(& boost::get(v), & value); return; } - typedef BOOST_DEDUCED_TYPENAME mpl::pop_front::type type; + typedef typename mpl::pop_front::type type; variant_impl::load(ar, which - 1, v, version); } }; @@ -120,7 +116,7 @@ struct variant_impl { V & v, const unsigned int version ){ - typedef BOOST_DEDUCED_TYPENAME mpl::eval_if, + typedef typename mpl::eval_if, mpl::identity, mpl::identity >::type typex; @@ -136,7 +132,7 @@ void load( const unsigned int version ){ int which; - typedef BOOST_DEDUCED_TYPENAME boost::variant::types types; + typedef typename boost::variant::types types; ar >> BOOST_SERIALIZATION_NVP(which); if(which >= mpl::size::value) // this might happen if a type was removed from the list of variant types diff --git a/src/thirdparty/boost_lib/boost/serialization/vector.hpp b/src/thirdparty/boost_lib/boost/serialization/vector.hpp index 7520c09a0..3af1d6769 100644 --- a/src/thirdparty/boost_lib/boost/serialization/vector.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/vector.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_VECTOR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -121,9 +121,9 @@ inline void save( const std::vector &t, const unsigned int file_version ){ - typedef BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::use_array_optimization::template apply< - BOOST_DEDUCED_TYPENAME remove_const::type + typename remove_const::type >::type use_optimized; save(ar,t,file_version, use_optimized()); } @@ -141,9 +141,9 @@ inline void load( return; } #endif - typedef BOOST_DEDUCED_TYPENAME + typedef typename boost::serialization::use_array_optimization::template apply< - BOOST_DEDUCED_TYPENAME remove_const::type + typename remove_const::type >::type use_optimized; load(ar,t,file_version, use_optimized()); } @@ -159,8 +159,6 @@ inline void serialize( boost::serialization::split_free(ar, t, file_version); } -#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // vector template @@ -207,8 +205,6 @@ inline void serialize( boost::serialization::split_free(ar, t, file_version); } -#endif // BOOST_WORKAROUND - } // serialization } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/serialization/version.hpp b/src/thirdparty/boost_lib/boost/serialization/version.hpp index ef3dff2f4..21a74d73d 100644 --- a/src/thirdparty/boost_lib/boost/serialization/version.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/version.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_VERSION_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -37,14 +37,14 @@ struct version { template struct traits_class_version { - typedef BOOST_DEDUCED_TYPENAME U::version type; + typedef typename U::version type; }; typedef mpl::integral_c_tag tag; // note: at least one compiler complained w/o the full qualification // on basic traits below typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if< + typename mpl::eval_if< is_base_and_derived, traits_class_version< T >, mpl::int_<0> diff --git a/src/thirdparty/boost_lib/boost/serialization/void_cast.hpp b/src/thirdparty/boost_lib/boost/serialization/void_cast.hpp index b5b1e8577..61b6449ef 100644 --- a/src/thirdparty/boost_lib/boost/serialization/void_cast.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/void_cast.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_VOID_CAST_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -181,13 +181,13 @@ void_caster_primitive::void_caster_primitive() : void_caster( & type_info_implementation::type::get_const_instance(), & type_info_implementation::type::get_const_instance(), - // note:I wanted to display from 0 here, but at least one compiler + // note:I wanted to displace from 0 here, but at least one compiler // treated 0 by not shifting it at all. reinterpret_cast( static_cast( - reinterpret_cast(1) + reinterpret_cast(8) ) - ) - 1 + ) - 8 ) { recursive_register(); @@ -248,7 +248,7 @@ struct void_caster_base : public void_caster { typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity< void_cast_detail::void_caster_virtual_base > @@ -268,7 +268,7 @@ inline const void_cast_detail::void_caster & void_cast_register( Base const * /* bnull = NULL */ ){ typedef - BOOST_DEDUCED_TYPENAME mpl::eval_if, + typename mpl::eval_if, mpl::identity< void_cast_detail::void_caster_virtual_base > diff --git a/src/thirdparty/boost_lib/boost/serialization/void_cast_fwd.hpp b/src/thirdparty/boost_lib/boost/serialization/void_cast_fwd.hpp index c94adb2ec..def61d52b 100644 --- a/src/thirdparty/boost_lib/boost/serialization/void_cast_fwd.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/void_cast_fwd.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/serialization/weak_ptr.hpp b/src/thirdparty/boost_lib/boost/serialization/weak_ptr.hpp index 3fe8698de..b3af8bfed 100644 --- a/src/thirdparty/boost_lib/boost/serialization/weak_ptr.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/weak_ptr.hpp @@ -2,7 +2,7 @@ #define BOOST_SERIALIZATION_WEAK_PTR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -55,4 +55,45 @@ inline void serialize( } // namespace serialization } // namespace boost +#ifndef BOOST_NO_CXX11_SMART_PTR +#include + +namespace boost { +namespace serialization{ + +template +inline void save( + Archive & ar, + const std::weak_ptr< T > &t, + const unsigned int /* file_version */ +){ + const std::shared_ptr< T > sp = t.lock(); + ar << boost::serialization::make_nvp("weak_ptr", sp); +} + +template +inline void load( + Archive & ar, + std::weak_ptr< T > &t, + const unsigned int /* file_version */ +){ + std::shared_ptr< T > sp; + ar >> boost::serialization::make_nvp("weak_ptr", sp); + t = sp; +} + +template +inline void serialize( + Archive & ar, + std::weak_ptr< T > &t, + const unsigned int file_version +){ + boost::serialization::split_free(ar, t, file_version); +} + +} // namespace serialization +} // namespace boost + +#endif // BOOST_NO_CXX11_SMART_PTR + #endif // BOOST_SERIALIZATION_WEAK_PTR_HPP diff --git a/src/thirdparty/boost_lib/boost/serialization/wrapper.hpp b/src/thirdparty/boost_lib/boost/serialization/wrapper.hpp index eeb4333ca..6a2a730dd 100644 --- a/src/thirdparty/boost_lib/boost/serialization/wrapper.hpp +++ b/src/thirdparty/boost_lib/boost/serialization/wrapper.hpp @@ -41,7 +41,7 @@ struct is_wrapper_impl : template struct is_wrapper { - typedef BOOST_DEDUCED_TYPENAME is_wrapper_impl::type type; + typedef typename is_wrapper_impl::type type; }; } // serialization diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/allocate_shared_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/allocate_shared_array.hpp index 3ee16552e..1ae5cc783 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/allocate_shared_array.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/allocate_shared_array.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012 Glen Joseph Fernandes + * Copyright (c) 2012-2014 Glen Joseph Fernandes * glenfe at live dot com * * Distributed under the Boost Software License, @@ -9,241 +9,172 @@ #ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP #define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP -#include -#include -#include -#include +#include #include -#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) -#include -#endif namespace boost { - template + template inline typename boost::detail::sp_if_array::type allocate_shared(const A& allocator, std::size_t size) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; - T1* p1 = 0; - T2* p2 = 0; + typedef boost::detail::ms_init_tag R1; + typedef boost::detail::as_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::allocate_array_helper a1(allocator, n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2); - return boost::shared_ptr(s1, p1); - } -#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - template - inline typename boost::detail::sp_if_array::type - allocate_shared(const A& allocator, std::size_t size, Args&&... args) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; T1* p1 = 0; T2* p2 = 0; - std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::allocate_array_helper a1(allocator, n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + D1 d1; + A1 a1(allocator, size, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + boost::detail::as_init(allocator, p2, n1); +#else + boost::detail::ms_init(p2, n1); +#endif + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(args)...); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_size_array::type - allocate_shared(const A& allocator, Args&&... args) { + allocate_shared(const A& allocator) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; + typedef boost::detail::ms_init_tag R1; + typedef boost::detail::as_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { N = boost::detail::array_total::size }; T1* p1 = 0; T2* p2 = 0; - boost::detail::allocate_array_helper a1(allocator, &p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(args)...); - return boost::shared_ptr(s1, p1); - } + D1 d1; + A1 a1(allocator, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + boost::detail::as_init(allocator, p2, N); +#else + boost::detail::ms_init(p2, N); #endif -#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) - template - inline typename boost::detail::sp_if_size_array::type - allocate_shared(const A& allocator, const T& list) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - typedef const T2 T3; - enum { - N = boost::detail::array_total::size - }; - T1* p1 = 0; - T2* p2 = 0; - T3* p3 = 0; - boost::detail::allocate_array_helper a1(allocator, &p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init_list(p2, p3); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_array::type allocate_shared(const A& allocator, std::size_t size, - const typename boost::detail::array_inner::type& list) { + const typename boost::detail::array_inner::type& value) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; typedef const T2 T3; + typedef boost::detail::ms_init_tag R1; + typedef boost::detail::as_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { M = boost::detail::array_total::size }; - T1* p1 = 0; - T2* p2 = 0; - T3* p3 = 0; std::size_t n1 = M * size; - boost::detail::allocate_array_helper a1(allocator, n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list); - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->template init_list(p2, p3); - return boost::shared_ptr(s1, p1); - } - template - inline typename boost::detail::sp_if_size_array::type - allocate_shared(const A& allocator, - const typename boost::detail::array_inner::type& list) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - typedef const T2 T3; - enum { - M = boost::detail::array_total::size, - N = boost::detail::array_total::size - }; - T1* p1 = 0; - T2* p2 = 0; - T3* p3 = 0; - boost::detail::allocate_array_helper a1(allocator, &p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list); - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->template init_list(p2, p3); - return boost::shared_ptr(s1, p1); - } -#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) - template - inline typename boost::detail::sp_if_array::type - allocate_shared(const A& allocator, - std::initializer_list::type> list) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - typedef const T2 T3; T1* p1 = 0; T2* p2 = 0; - T3* p3 = 0; - std::size_t n1 = list.size() * boost::detail::array_total::size; - boost::detail::allocate_array_helper a1(allocator, n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list.begin()); - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init_list(p2, p3); - return boost::shared_ptr(s1, p1); - } + T3* p3 = reinterpret_cast(&value); + D1 d1; + A1 a1(allocator, size, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + boost::detail::as_init(allocator, p2, n1, p3); +#else + boost::detail::ms_init(p2, n1, p3); #endif -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - template - inline typename boost::detail::sp_if_array::type - allocate_shared(const A& allocator, std::size_t size, - typename boost::detail::array_base::type&& value) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - T1* p1 = 0; - T2* p2 = 0; - std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::allocate_array_helper a1(allocator, n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(value)); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_size_array::type - allocate_shared(const A& allocator, - typename boost::detail::array_base::type&& value) { + allocate_shared(const A& allocator, + const typename boost::detail::array_inner::type& value) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; + typedef const T2 T3; + typedef boost::detail::ms_init_tag R1; + typedef boost::detail::as_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { - N = boost::detail::array_total::size + N = boost::detail::array_total::size, + M = boost::detail::array_total::size }; T1* p1 = 0; T2* p2 = 0; - boost::detail::allocate_array_helper a1(allocator, &p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + T3* p3 = reinterpret_cast(&value); + D1 d1; + A1 a1(allocator, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + boost::detail::as_init(allocator, p2, N, p3); +#else + boost::detail::ms_init(p2, N, p3); +#endif + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(value)); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } -#endif -#endif - template + + template inline typename boost::detail::sp_if_array::type allocate_shared_noinit(const A& allocator, std::size_t size) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; + typedef boost::detail::ms_noinit_tag R1; + typedef boost::detail::as_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; + std::size_t n1 = size * boost::detail::array_total::size; T1* p1 = 0; T2* p2 = 0; - std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::allocate_array_helper a1(allocator, n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + D1 d1; + A1 a1(allocator, size, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_noinit(p2, n1); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->noinit(p2); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_size_array::type allocate_shared_noinit(const A& allocator) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; + typedef boost::detail::ms_noinit_tag R1; + typedef boost::detail::as_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { N = boost::detail::array_total::size }; T1* p1 = 0; T2* p2 = 0; - boost::detail::allocate_array_helper a1(allocator, &p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + D1 d1; + A1 a1(allocator, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_noinit(p2, N); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->noinit(p2); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } } diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/allocate_array_helper.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/allocate_array_helper.hpp deleted file mode 100644 index 2eeea2d3f..000000000 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/allocate_array_helper.hpp +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright (c) 2012 Glen Joseph Fernandes - * glenfe at live dot com - * - * Distributed under the Boost Software License, - * Version 1.0. (See accompanying file LICENSE_1_0.txt - * or copy at http://boost.org/LICENSE_1_0.txt) - */ -#ifndef BOOST_SMART_PTR_DETAIL_ALLOCATE_ARRAY_HELPER_HPP -#define BOOST_SMART_PTR_DETAIL_ALLOCATE_ARRAY_HELPER_HPP - -#include - -namespace boost { - namespace detail { - template - class allocate_array_helper; - template - class allocate_array_helper { - template - friend class allocate_array_helper; - typedef typename A::template rebind ::other A2; - typedef typename A::template rebind::other A3; - public: - typedef typename A2::value_type value_type; - typedef typename A2::pointer pointer; - typedef typename A2::const_pointer const_pointer; - typedef typename A2::reference reference; - typedef typename A2::const_reference const_reference; - typedef typename A2::size_type size_type; - typedef typename A2::difference_type difference_type; - template - struct rebind { - typedef allocate_array_helper other; - }; - allocate_array_helper(const A& allocator_, std::size_t size_, T** data_) - : allocator(allocator_), - size(sizeof(T) * size_), - data(data_) { - } - template - allocate_array_helper(const allocate_array_helper& other) - : allocator(other.allocator), - size(other.size), - data(other.data) { - } - pointer address(reference value) const { - return allocator.address(value); - } - const_pointer address(const_reference value) const { - return allocator.address(value); - } - size_type max_size() const { - return allocator.max_size(); - } - pointer allocate(size_type count, const void* value = 0) { - std::size_t a1 = boost::alignment_of::value; - std::size_t n1 = count * sizeof(Y) + a1 - 1; - char* p1 = A3(allocator).allocate(n1 + size, value); - char* p2 = p1 + n1; - while (std::size_t(p2) % a1 != 0) { - p2--; - } - *data = reinterpret_cast(p2); - return reinterpret_cast(p1); - } - void deallocate(pointer memory, size_type count) { - std::size_t a1 = boost::alignment_of::value; - std::size_t n1 = count * sizeof(Y) + a1 - 1; - char* p1 = reinterpret_cast(memory); - A3(allocator).deallocate(p1, n1 + size); - } - void construct(pointer memory, const Y& value) { - allocator.construct(memory, value); - } - void destroy(pointer memory) { - allocator.destroy(memory); - } - template - bool operator==(const allocate_array_helper& other) const { - return allocator == other.allocator; - } - template - bool operator!=(const allocate_array_helper& other) const { - return !(*this == other); - } - private: - A2 allocator; - std::size_t size; - T** data; - }; - template - class allocate_array_helper { - template - friend class allocate_array_helper; - typedef typename A::template rebind ::other A2; - typedef typename A::template rebind::other A3; - public: - typedef typename A2::value_type value_type; - typedef typename A2::pointer pointer; - typedef typename A2::const_pointer const_pointer; - typedef typename A2::reference reference; - typedef typename A2::const_reference const_reference; - typedef typename A2::size_type size_type; - typedef typename A2::difference_type difference_type; - template - struct rebind { - typedef allocate_array_helper other; - }; - allocate_array_helper(const A& allocator_, T** data_) - : allocator(allocator_), - data(data_) { - } - template - allocate_array_helper(const allocate_array_helper& other) - : allocator(other.allocator), - data(other.data) { - } - pointer address(reference value) const { - return allocator.address(value); - } - const_pointer address(const_reference value) const { - return allocator.address(value); - } - size_type max_size() const { - return allocator.max_size(); - } - pointer allocate(size_type count, const void* value = 0) { - std::size_t a1 = boost::alignment_of::value; - std::size_t n1 = count * sizeof(Y) + a1 - 1; - char* p1 = A3(allocator).allocate(n1 + N1, value); - char* p2 = p1 + n1; - while (std::size_t(p2) % a1 != 0) { - p2--; - } - *data = reinterpret_cast(p2); - return reinterpret_cast(p1); - } - void deallocate(pointer memory, size_type count) { - std::size_t a1 = boost::alignment_of::value; - std::size_t n1 = count * sizeof(Y) + a1 - 1; - char* p1 = reinterpret_cast(memory); - A3(allocator).deallocate(p1, n1 + N1); - } - void construct(pointer memory, const Y& value) { - allocator.construct(memory, value); - } - void destroy(pointer memory) { - allocator.destroy(memory); - } - template - bool operator==(const allocate_array_helper& other) const { - return allocator == other.allocator; - } - template - bool operator!=(const allocate_array_helper& other) const { - return !(*this == other); - } - private: - enum { - N1 = N * sizeof(T) - }; - A2 allocator; - T** data; - }; - } -} - -#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_allocator.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_allocator.hpp new file mode 100644 index 000000000..4f9dc2b4b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_allocator.hpp @@ -0,0 +1,318 @@ +/* + * Copyright (c) 2012-2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP +#define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP + +#include +#include +#include +#include + +namespace boost { + namespace detail { + struct ms_init_tag { }; + struct ms_noinit_tag { }; + + template + struct ms_allocator_state; + + template + struct ms_allocator_state { + typedef typename array_base::type type; + + ms_allocator_state(std::size_t size_, + type** result_) + : size(size_ * array_total::size), + result(result_) { + } + + std::size_t size; + + union { + type** result; + type* object; + }; + }; + + template + struct ms_allocator_state { + typedef typename array_base::type type; + + ms_allocator_state(type** result_) + : result(result_) { + } + + enum { + size = array_total::size + }; + + union { + type** result; + type* object; + }; + }; + + template + class as_allocator + : public A { + template + friend class as_allocator; + +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef std::allocator_traits AT; + typedef typename AT::template rebind_alloc CA; + typedef typename AT::template rebind_traits CT; +#else + typedef typename A::template rebind::other CA; +#endif + + public: + typedef A allocator_type; + +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef typename AT::value_type value_type; + typedef typename AT::pointer pointer; + typedef typename AT::const_pointer const_pointer; + typedef typename AT::void_pointer void_pointer; + typedef typename AT::const_void_pointer const_void_pointer; + typedef typename AT::size_type size_type; + typedef typename AT::difference_type difference_type; +#else + typedef typename A::value_type value_type; + typedef typename A::pointer pointer; + typedef typename A::const_pointer const_pointer; + typedef typename A::size_type size_type; + typedef typename A::difference_type difference_type; + typedef typename A::reference reference; + typedef typename A::const_reference const_reference; + typedef void* void_pointer; + typedef const void* const_void_pointer; +#endif + + template + struct rebind { +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef as_allocator, T, R> other; +#else + typedef as_allocator::other, T, R> other; +#endif + }; + + typedef typename array_base::type type; + + as_allocator(const A& allocator_, type** result) + : A(allocator_), + data(result) { + } + + as_allocator(const A& allocator_, std::size_t size, + type** result) + : A(allocator_), + data(size, result) { + } + + template + as_allocator(const as_allocator& other) + : A(other.allocator()), + data(other.data) { + } + + pointer allocate(size_type count, const_void_pointer = 0) { + enum { + M = boost::alignment_of::value + }; + std::size_t n1 = count * sizeof(value_type); + std::size_t n2 = data.size * sizeof(type); + std::size_t n3 = n2 + M; + CA ca(allocator()); + void* p1 = ca.allocate(n1 + n3); + void* p2 = static_cast(p1) + n1; + (void)boost::alignment::align(M, n2, p2, n3); + *data.result = static_cast(p2); + return static_cast(p1); + } + + void deallocate(pointer memory, size_type count) { + enum { + M = boost::alignment_of::value + }; + std::size_t n1 = count * sizeof(value_type); + std::size_t n2 = data.size * sizeof(type) + M; + char* p1 = reinterpret_cast(memory); + CA ca(allocator()); + ca.deallocate(p1, n1 + n2); + } + + const A& allocator() const { + return static_cast(*this); + } + + A& allocator() { + return static_cast(*this); + } + + void set(type* memory) { + data.object = memory; + } + + void operator()() { + if (data.object) { + R tag; + release(tag); + } + } + + private: + void release(ms_init_tag) { +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + as_destroy(allocator(), data.object, data.size); +#else + ms_destroy(data.object, data.size); +#endif + } + + void release(ms_noinit_tag) { + ms_destroy(data.object, data.size); + } + + ms_allocator_state data; + }; + + template + bool operator==(const as_allocator& a1, + const as_allocator& a2) { + return a1.allocator() == a2.allocator(); + } + + template + bool operator!=(const as_allocator& a1, + const as_allocator& a2) { + return a1.allocator() != a2.allocator(); + } + + template + class ms_allocator; + + template + class ms_allocator { + template + friend class ms_allocator; + + public: + typedef typename array_base::type type; + + typedef Y value_type; + typedef Y* pointer; + typedef const Y* const_pointer; + typedef std::size_t size_type; + typedef ptrdiff_t difference_type; + typedef Y& reference; + typedef const Y& const_reference; + + template + struct rebind { + typedef ms_allocator other; + }; + + ms_allocator(type** result) + : data(result) { + } + + ms_allocator(std::size_t size, type** result) + : data(size, result) { + } + + template + ms_allocator(const ms_allocator& other) + : data(other.data) { + } + + pointer allocate(size_type count, const void* = 0) { + enum { + M = boost::alignment_of::value + }; + std::size_t n1 = count * sizeof(Y); + std::size_t n2 = data.size * sizeof(type); + std::size_t n3 = n2 + M; + void* p1 = ::operator new(n1 + n3); + void* p2 = static_cast(p1) + n1; + (void)boost::alignment::align(M, n2, p2, n3); + *data.result = static_cast(p2); + return static_cast(p1); + } + + void deallocate(pointer memory, size_type) { + void* p1 = memory; + ::operator delete(p1); + } + +#if defined(BOOST_NO_CXX11_ALLOCATOR) + pointer address(reference value) const { + return &value; + } + + const_pointer address(const_reference value) const { + return &value; + } + + size_type max_size() const { + enum { + N = static_cast(-1) / sizeof(Y) + }; + return N; + } + + void construct(pointer memory, const_reference value) { + void* p1 = memory; + ::new(p1) Y(value); + } + + void destroy(pointer memory) { + (void)memory; + memory->~Y(); + } +#endif + + void set(type* memory) { + data.object = memory; + } + + void operator()() { + if (data.object) { + ms_destroy(data.object, data.size); + } + } + + private: + ms_allocator_state data; + }; + + template + bool operator==(const ms_allocator&, + const ms_allocator&) { + return true; + } + + template + bool operator!=(const ms_allocator&, + const ms_allocator&) { + return false; + } + + class ms_in_allocator_tag { + public: + void operator()(const void*) { + } + }; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_count_impl.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_count_impl.hpp new file mode 100644 index 000000000..b7c9617f0 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_count_impl.hpp @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP +#define BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP + +#include +#include + +namespace boost { + namespace detail { + template + class sp_counted_impl_pda + : public sp_counted_base { + typedef ms_in_allocator_tag D; + typedef sp_counted_impl_pda Y; + public: + sp_counted_impl_pda(P, D, const A& allocator_) + : allocator(allocator_) { + } + + virtual void dispose() { + allocator(); + } + + virtual void destroy() { +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + typedef typename std::allocator_traits:: + template rebind_alloc YA; + typedef typename std::allocator_traits:: + template rebind_traits YT; +#else + typedef typename A::template rebind::other YA; +#endif + YA a1(allocator); +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + YT::destroy(a1, this); + YT::deallocate(a1, this, 1); +#else + this->~Y(); + a1.deallocate(this, 1); +#endif + } + + virtual void* get_deleter(const sp_typeinfo&) { + return &reinterpret_cast(allocator); + } + + virtual void* get_untyped_deleter() { + return &reinterpret_cast(allocator); + } + + private: + sp_counted_impl_pda(const sp_counted_impl_pda&); + sp_counted_impl_pda& operator=(const sp_counted_impl_pda&); + + A allocator; + }; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_deleter.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_deleter.hpp deleted file mode 100644 index 20f84d1e7..000000000 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_deleter.hpp +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (c) 2012 Glen Joseph Fernandes - * glenfe at live dot com - * - * Distributed under the Boost Software License, - * Version 1.0. (See accompanying file LICENSE_1_0.txt - * or copy at http://boost.org/LICENSE_1_0.txt) - */ -#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP -#define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP - -#include -#include - -namespace boost { - namespace detail { - template - class array_deleter; - template - class array_deleter { - public: - array_deleter(std::size_t size_) - : size(size_), - object(0) { - } - ~array_deleter() { - if (object) { - array_destroy(object, size); - } - } - void init(T* memory) { - array_init(memory, size); - object = memory; - } -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - void init(T* memory, T&& value) { - array_init_value(memory, size, sp_forward(value)); - object = memory; - } -#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) - template - void init(T* memory, Args&&... args) { - array_init_args(memory, size, sp_forward(args)...); - object = memory; - } -#endif -#endif - void init_list(T* memory, const T* list) { - array_init_list(memory, size, list); - object = memory; - } - template - void init_list(T* memory, const T* list) { - array_init_list(memory, size, list); - object = memory; - } - void noinit(T* memory) { - array_noinit(memory, size); - object = memory; - } - void operator()(const void*) { - if (object) { - array_destroy(object, size); - object = 0; - } - } - private: - std::size_t size; - T* object; - }; - template - class array_deleter { - public: - array_deleter() - : object(0) { - } - ~array_deleter() { - if (object) { - array_destroy(object, N); - } - } - void init(T* memory) { - array_init(memory, N); - object = memory; - } -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - void init(T* memory, T&& value) { - array_init_value(memory, N, sp_forward(value)); - object = memory; - } -#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) - template - void init(T* memory, Args&&... args) { - array_init_args(memory, N, sp_forward(args)...); - object = memory; - } -#endif -#endif - void init_list(T* memory, const T* list) { - array_init_list(memory, N, list); - object = memory; - } - template - void init_list(T* memory, const T* list) { - array_init_list(memory, N, list); - object = memory; - } - void noinit(T* memory) { - array_noinit(memory, N); - object = memory; - } - void operator()(const void*) { - if (object) { - array_destroy(object, N); - object = 0; - } - } - private: - T* object; - }; - } -} - -#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_traits.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_traits.hpp index 8ef787479..819c5ba61 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_traits.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_traits.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012 Glen Joseph Fernandes + * Copyright (c) 2012-2014 Glen Joseph Fernandes * glenfe at live dot com * * Distributed under the Boost Software License, @@ -13,37 +13,44 @@ namespace boost { namespace detail { - template + template struct array_base { typedef typename boost::remove_cv::type type; }; - template + + template struct array_base { typedef typename array_base::type type; }; - template + + template struct array_base { typedef typename array_base::type type; }; - template + + template struct array_total { enum { size = 1 }; }; - template + + template struct array_total { enum { size = N * array_total::size }; }; - template + + template struct array_inner; - template + + template struct array_inner { typedef T type; }; - template + + template struct array_inner { typedef T type; }; diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_utility.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_utility.hpp index 3cf36d744..84029a1d7 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_utility.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/array_utility.hpp @@ -1,9 +1,9 @@ /* - * Copyright (c) 2012 Glen Joseph Fernandes + * Copyright (c) 2012-2014 Glen Joseph Fernandes * glenfe at live dot com * - * Distributed under the Boost Software License, - * Version 1.0. (See accompanying file LICENSE_1_0.txt + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt * or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP @@ -12,31 +12,42 @@ #include #include #include +#if !defined(BOOST_NO_CXX11_ALLOCATOR) +#include +#endif namespace boost { namespace detail { - template - inline void array_destroy(T*, std::size_t, boost::true_type) { + typedef boost::true_type ms_is_trivial; + typedef boost::false_type ms_no_trivial; + + template + inline void ms_destroy(T*, std::size_t, ms_is_trivial) { } - template - inline void array_destroy(T* memory, std::size_t size, boost::false_type) { - for (std::size_t i = size; i > 0; ) { + + template + inline void ms_destroy(T* memory, std::size_t size, ms_no_trivial) { + for (std::size_t i = size; i > 0;) { memory[--i].~T(); } } - template - inline void array_destroy(T* memory, std::size_t size) { - boost::has_trivial_destructor type; - array_destroy(memory, size, type); + + template + inline void ms_destroy(T* memory, std::size_t size) { + boost::has_trivial_destructor trivial; + ms_destroy(memory, size, trivial); } - template - inline void array_init(T* memory, std::size_t size, boost::true_type) { + + template + inline void ms_init(T* memory, std::size_t size, ms_is_trivial) { for (std::size_t i = 0; i < size; i++) { - memory[i] = T(); + void* p1 = memory + i; + ::new(p1) T(); } } - template - inline void array_init(T* memory, std::size_t size, boost::false_type) { + + template + inline void ms_init(T* memory, std::size_t size, ms_no_trivial) { #if !defined(BOOST_NO_EXCEPTIONS) std::size_t i = 0; try { @@ -45,7 +56,7 @@ namespace boost { ::new(p1) T(); } } catch (...) { - array_destroy(memory, i); + ms_destroy(memory, i); throw; } #else @@ -55,100 +66,124 @@ namespace boost { } #endif } - template - inline void array_init(T* memory, std::size_t size) { - boost::has_trivial_default_constructor type; - array_init(memory, size, type); + + template + inline void ms_init(T* memory, std::size_t size) { + boost::has_trivial_default_constructor trivial; + ms_init(memory, size, trivial); } -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - template - inline void array_init_value(T* memory, std::size_t size, T&& value) { + + template + inline void ms_init(T* memory, std::size_t size, const T* list) { #if !defined(BOOST_NO_EXCEPTIONS) std::size_t i = 0; try { for (; i < size; i++) { void* p1 = memory + i; - ::new(p1) T(value); + ::new(p1) T(list[i % N]); } } catch (...) { - array_destroy(memory, i); + ms_destroy(memory, i); throw; } #else for (std::size_t i = 0; i < size; i++) { void* p1 = memory + i; - ::new(p1) T(value); + ::new(p1) T(list[i % N]); } #endif } -#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) - template - inline void array_init_args(T* memory, std::size_t size, Args&&... args) { -#if !defined(BOOST_NO_EXCEPTIONS) - std::size_t i = 0; - try { - for (; i < size; i++) { - void* p1 = memory + i; - ::new(p1) T(args...); - } - } catch (...) { - array_destroy(memory, i); - throw; + +#if !defined(BOOST_NO_CXX11_ALLOCATOR) + template + inline void as_destroy(const A& allocator, T* memory, + std::size_t size) { + typedef typename std::allocator_traits:: + template rebind_alloc TA; + typedef typename std::allocator_traits:: + template rebind_traits TT; + TA a2(allocator); + for (std::size_t i = size; i > 0;) { + TT::destroy(a2, &memory[--i]); } -#else + } + + template + inline void as_init(const A& allocator, T* memory, std::size_t size, + ms_is_trivial) { + typedef typename std::allocator_traits:: + template rebind_alloc TA; + typedef typename std::allocator_traits:: + template rebind_traits TT; + TA a2(allocator); for (std::size_t i = 0; i < size; i++) { - void* p1 = memory + i; - ::new(p1) T(args...); + TT::construct(a2, memory + i); } -#endif } -#endif -#endif - template - inline void array_init_list(T* memory, std::size_t size, const T* list) { + + template + inline void as_init(const A& allocator, T* memory, std::size_t size, + ms_no_trivial) { + typedef typename std::allocator_traits:: + template rebind_alloc TA; + typedef typename std::allocator_traits:: + template rebind_traits TT; + TA a2(allocator); #if !defined(BOOST_NO_EXCEPTIONS) std::size_t i = 0; try { for (; i < size; i++) { - void* p1 = memory + i; - ::new(p1) T(list[i]); + TT::construct(a2, memory + i); } } catch (...) { - array_destroy(memory, i); + as_destroy(a2, memory, i); throw; } #else for (std::size_t i = 0; i < size; i++) { - void* p1 = memory + i; - ::new(p1) T(list[i]); + TT::construct(a2, memory + i); } #endif } - template - inline void array_init_list(T* memory, std::size_t size, const T* list) { + + template + inline void as_init(const A& allocator, T* memory, std::size_t size) { + boost::has_trivial_default_constructor trivial; + as_init(allocator, memory, size, trivial); + } + + template + inline void as_init(const A& allocator, T* memory, std::size_t size, + const T* list) { + typedef typename std::allocator_traits:: + template rebind_alloc TA; + typedef typename std::allocator_traits:: + template rebind_traits TT; + TA a2(allocator); #if !defined(BOOST_NO_EXCEPTIONS) std::size_t i = 0; try { for (; i < size; i++) { - void* p1 = memory + i; - ::new(p1) T(list[i % N]); + TT::construct(a2, memory + i, list[i % N]); } } catch (...) { - array_destroy(memory, i); + as_destroy(a2, memory, i); throw; } #else for (std::size_t i = 0; i < size; i++) { - void* p1 = memory + i; - ::new(p1) T(list[i % N]); + TT::construct(a2, memory + i, list[i % N]); } #endif } - template - inline void array_noinit(T*, std::size_t, boost::true_type) { +#endif + + template + inline void ms_noinit(T*, std::size_t, ms_is_trivial) { } - template - inline void array_noinit(T* memory, std::size_t size, boost::false_type) { + + template + inline void ms_noinit(T* memory, std::size_t size, ms_no_trivial) { #if !defined(BOOST_NO_EXCEPTIONS) std::size_t i = 0; try { @@ -157,7 +192,7 @@ namespace boost { ::new(p1) T; } } catch (...) { - array_destroy(memory, i); + ms_destroy(memory, i); throw; } #else @@ -167,10 +202,11 @@ namespace boost { } #endif } - template - inline void array_noinit(T* memory, std::size_t size) { - boost::has_trivial_default_constructor type; - array_noinit(memory, size, type); + + template + inline void ms_noinit(T* memory, std::size_t size) { + boost::has_trivial_default_constructor trivial; + ms_noinit(memory, size, trivial); } } } diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count.hpp index cc44ac2f9..8aefd44fd 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count.hpp @@ -11,10 +11,11 @@ // boost/detail/atomic_count.hpp - thread/SMP safe reference counter // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. +// Copyright (c) 2013 Peter Dimov // -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) +// 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 // // typedef boost::detail::atomic_count; // @@ -27,92 +28,68 @@ // a; // // Returns: (long) the current value of a +// Memory Ordering: acquire // // ++a; // // Effects: Atomically increments the value of a // Returns: (long) the new value of a +// Memory Ordering: acquire/release // // --a; // // Effects: Atomically decrements the value of a // Returns: (long) the new value of a -// -// Important note: when --a returns zero, it must act as a -// read memory barrier (RMB); i.e. the calling thread must -// have a synchronized view of the memory -// -// On Intel IA-32 (x86) memory is always synchronized, so this -// is not a problem. -// -// On many architectures the atomic instructions already act as -// a memory barrier. -// -// This property is necessary for proper reference counting, since -// a thread can update the contents of a shared object, then -// release its reference, and another thread may immediately -// release the last reference causing object destruction. -// -// The destructor needs to have a synchronized view of the -// object to perform proper cleanup. -// -// Original example by Alexander Terekhov: -// -// Given: -// -// - a mutable shared object OBJ; -// - two threads THREAD1 and THREAD2 each holding -// a private smart_ptr object pointing to that OBJ. -// -// t1: THREAD1 updates OBJ (thread-safe via some synchronization) -// and a few cycles later (after "unlock") destroys smart_ptr; -// -// t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization -// with respect to shared mutable object OBJ; OBJ destructors -// are called driven by smart_ptr interface... +// Memory Ordering: acquire/release // #include #include -#ifndef BOOST_HAS_THREADS +#if defined( BOOST_AC_DISABLE_THREADS ) +# include -namespace boost -{ +#elif defined( BOOST_AC_USE_STD_ATOMIC ) +# include -namespace detail -{ +#elif defined( BOOST_AC_USE_SPINLOCK ) +# include -typedef long atomic_count; +#elif defined( BOOST_AC_USE_PTHREADS ) +# include -} +#elif defined( BOOST_SP_DISABLE_THREADS ) +# include -} +#elif defined( BOOST_SP_USE_STD_ATOMIC ) +# include -#elif defined(BOOST_AC_USE_PTHREADS) -# include +#elif defined( BOOST_SP_USE_SPINLOCK ) +# include -#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) -# include +#elif defined( BOOST_SP_USE_PTHREADS ) +# include -#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# include +#elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 ) +# include + +#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) && !defined( __PATHSCALE__ ) +# include #elif defined( BOOST_SP_HAS_SYNC ) -# include +# include -#elif defined(__GLIBCPP__) || defined(__GLIBCXX__) -# include +#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# include -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(__GLIBCPP__) || defined(__GLIBCXX__) +# include -# define BOOST_AC_USE_PTHREADS -# include +#elif !defined( BOOST_HAS_THREADS ) +# include #else - -// Use #define BOOST_DISABLE_THREADS to avoid the error -#error Unrecognized threading platform +# include #endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_nt.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_nt.hpp new file mode 100644 index 000000000..3bbf13891 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_nt.hpp @@ -0,0 +1,59 @@ +#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_NT_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_NT_HPP_INCLUDED + +// +// boost/detail/atomic_count_nt.hpp +// +// Trivial atomic_count for the single-threaded case +// +// http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html +// +// Copyright 2013 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// + +namespace boost +{ + +namespace detail +{ + +class atomic_count +{ +public: + + explicit atomic_count( long v ): value_( v ) + { + } + + long operator++() + { + return ++value_; + } + + long operator--() + { + return --value_; + } + + operator long() const + { + return value_; + } + +private: + + atomic_count(atomic_count const &); + atomic_count & operator=(atomic_count const &); + + long value_; +}; + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_NT_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_pthreads.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_pt.hpp similarity index 85% rename from src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_pthreads.hpp rename to src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_pt.hpp index 05f78673c..f99b9108e 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_pthreads.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_pt.hpp @@ -11,6 +11,7 @@ // http://www.boost.org/LICENSE_1_0.txt) // +#include #include // @@ -37,12 +38,12 @@ class atomic_count scoped_lock(pthread_mutex_t & m): m_(m) { - pthread_mutex_lock(&m_); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); } ~scoped_lock() { - pthread_mutex_unlock(&m_); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); } private: @@ -54,12 +55,12 @@ class atomic_count explicit atomic_count(long v): value_(v) { - pthread_mutex_init(&mutex_, 0); + BOOST_VERIFY( pthread_mutex_init( &mutex_, 0 ) == 0 ); } ~atomic_count() { - pthread_mutex_destroy(&mutex_); + BOOST_VERIFY( pthread_mutex_destroy( &mutex_ ) == 0 ); } long operator++() diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_spin.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_spin.hpp new file mode 100644 index 000000000..8e623496b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_spin.hpp @@ -0,0 +1,62 @@ +#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SPIN_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SPIN_HPP_INCLUDED + +// +// boost/detail/atomic_count_spin.hpp +// +// Copyright (c) 2013 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// + +#include + +namespace boost +{ + +namespace detail +{ + +class atomic_count +{ +private: + +public: + + explicit atomic_count( long v ): value_( v ) + { + } + + long operator++() + { + spinlock_pool<0>::scoped_lock lock( &value_ ); + return ++value_; + } + + long operator--() + { + spinlock_pool<0>::scoped_lock lock( &value_ ); + return --value_; + } + + operator long() const + { + spinlock_pool<0>::scoped_lock lock( &value_ ); + return value_; + } + +private: + + atomic_count(atomic_count const &); + atomic_count & operator=(atomic_count const &); + + long value_; +}; + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SPIN_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_std_atomic.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_std_atomic.hpp new file mode 100644 index 000000000..55b9998e5 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_std_atomic.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_STD_ATOMIC_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_STD_ATOMIC_HPP_INCLUDED + +// +// boost/detail/atomic_count_std_atomic.hpp +// +// atomic_count for std::atomic +// +// Copyright 2013 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// + +#include +#include + +namespace boost +{ + +namespace detail +{ + +class atomic_count +{ +public: + + explicit atomic_count( long v ): value_( v ) + { + } + + long operator++() + { + return value_.fetch_add( 1, std::memory_order_acq_rel ) + 1; + } + + long operator--() + { + return value_.fetch_sub( 1, std::memory_order_acq_rel ) - 1; + } + + operator long() const + { + return value_.load( std::memory_order_acquire ); + } + +private: + + atomic_count(atomic_count const &); + atomic_count & operator=(atomic_count const &); + + std::atomic_int_least32_t value_; +}; + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_STD_ATOMIC_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_win32.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_win32.hpp index 60a056943..633e73c3c 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_win32.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/atomic_count_win32.hpp @@ -17,7 +17,7 @@ // http://www.boost.org/LICENSE_1_0.txt) // -#include +#include namespace boost { @@ -35,12 +35,12 @@ class atomic_count long operator++() { - return BOOST_INTERLOCKED_INCREMENT( &value_ ); + return BOOST_SP_INTERLOCKED_INCREMENT( &value_ ); } long operator--() { - return BOOST_INTERLOCKED_DECREMENT( &value_ ); + return BOOST_SP_INTERLOCKED_DECREMENT( &value_ ); } operator long() const diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/lwm_win32_cs.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/lwm_win32_cs.hpp index 00477e49f..a93cf0920 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/lwm_win32_cs.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/lwm_win32_cs.hpp @@ -11,12 +11,15 @@ // boost/detail/lwm_win32_cs.hpp // // Copyright (c) 2002, 2003 Peter Dimov +// Copyright (c) Microsoft Corporation 2014 // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // +#include + #ifdef BOOST_USE_WINDOWS_H # include #endif @@ -43,7 +46,11 @@ struct critical_section #endif }; +#if BOOST_PLAT_WINDOWS_RUNTIME +extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long); +#else extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *); +#endif extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *); extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *); extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *); @@ -67,7 +74,11 @@ class lightweight_mutex lightweight_mutex() { +#if BOOST_PLAT_WINDOWS_RUNTIME + InitializeCriticalSectionEx(&cs_, 4000, 0); +#else InitializeCriticalSection(&cs_); +#endif } ~lightweight_mutex() diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/make_array_helper.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/make_array_helper.hpp deleted file mode 100644 index 6cf048316..000000000 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/make_array_helper.hpp +++ /dev/null @@ -1,157 +0,0 @@ -/* - * Copyright (c) 2012 Glen Joseph Fernandes - * glenfe at live dot com - * - * Distributed under the Boost Software License, - * Version 1.0. (See accompanying file LICENSE_1_0.txt - * or copy at http://boost.org/LICENSE_1_0.txt) - */ -#ifndef BOOST_SMART_PTR_DETAIL_MAKE_ARRAY_HELPER_HPP -#define BOOST_SMART_PTR_DETAIL_MAKE_ARRAY_HELPER_HPP - -#include - -namespace boost { - namespace detail { - template - class make_array_helper; - template - class make_array_helper { - template - friend class make_array_helper; - public: - typedef Y value_type; - typedef Y* pointer; - typedef const Y* const_pointer; - typedef Y& reference; - typedef const Y& const_reference; - typedef std::size_t size_type; - typedef ptrdiff_t difference_type; - template - struct rebind { - typedef make_array_helper other; - }; - make_array_helper(std::size_t size_, T** data_) - : size(sizeof(T) * size_), - data(data_) { - } - template - make_array_helper(const make_array_helper& other) - : size(other.size), - data(other.data) { - } - pointer address(reference value) const { - return &value; - } - const_pointer address(const_reference value) const { - return &value; - } - size_type max_size() const { - return static_cast(-1) / sizeof(Y); - } - pointer allocate(size_type count, const void* = 0) { - std::size_t a1 = boost::alignment_of::value; - std::size_t n1 = count * sizeof(Y) + a1 - 1; - void* p1 = ::operator new(n1 + size); - char* p2 = static_cast(p1) + n1; - while (std::size_t(p2) % a1 != 0) { - p2--; - } - *data = reinterpret_cast(p2); - return reinterpret_cast(p1); - } - void deallocate(pointer memory, size_type) { - void* p1 = memory; - ::operator delete(p1); - } - void construct(pointer memory, const Y& value) { - void* p1 = memory; - ::new(p1) Y(value); - } - void destroy(pointer memory) { - memory->~Y(); - } - template - bool operator==(const make_array_helper&) const { - return true; - } - template - bool operator!=(const make_array_helper& other) const { - return !(*this == other); - } - private: - std::size_t size; - T** data; - }; - template - class make_array_helper { - template - friend class make_array_helper; - public: - typedef Y value_type; - typedef Y* pointer; - typedef const Y* const_pointer; - typedef Y& reference; - typedef const Y& const_reference; - typedef std::size_t size_type; - typedef ptrdiff_t difference_type; - template - struct rebind { - typedef make_array_helper other; - }; - make_array_helper(T** data_) - : data(data_) { - } - template - make_array_helper(const make_array_helper& other) - : data(other.data) { - } - pointer address(reference value) const { - return &value; - } - const_pointer address(const_reference value) const { - return &value; - } - size_type max_size() const { - return static_cast(-1) / sizeof(Y); - } - pointer allocate(size_type count, const void* = 0) { - std::size_t a1 = boost::alignment_of::value; - std::size_t n1 = count * sizeof(Y) + a1 - 1; - void* p1 = ::operator new(n1 + N1); - char* p2 = static_cast(p1) + n1; - while (std::size_t(p2) % a1 != 0) { - p2--; - } - *data = reinterpret_cast(p2); - return reinterpret_cast(p1); - } - void deallocate(pointer memory, size_type) { - void* p1 = memory; - ::operator delete(p1); - } - void construct(pointer memory, const Y& value) { - void* p1 = memory; - ::new(p1) Y(value); - } - void destroy(pointer memory) { - memory->~Y(); - } - template - bool operator==(const make_array_helper&) const { - return true; - } - template - bool operator!=(const make_array_helper& other) const { - return !(*this == other); - } - private: - enum { - N1 = N * sizeof(T) - }; - T** data; - }; - } -} - -#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_array_nmt.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_array_nmt.hpp deleted file mode 100644 index 450c9bcf5..000000000 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_array_nmt.hpp +++ /dev/null @@ -1,151 +0,0 @@ -#ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED -#define BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED - -// -// detail/shared_array_nmt.hpp - shared_array.hpp without member templates -// -// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. -// Copyright (c) 2001, 2002 Peter Dimov -// -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation. -// - -#include -#include -#include -#include - -#include // for std::ptrdiff_t -#include // for std::swap -#include // for std::less -#include // for std::bad_alloc - -namespace boost -{ - -template class shared_array -{ -private: - - typedef detail::atomic_count count_type; - -public: - - typedef T element_type; - - explicit shared_array(T * p = 0): px(p) - { -#ifndef BOOST_NO_EXCEPTIONS - - try // prevent leak if new throws - { - pn = new count_type(1); - } - catch(...) - { - boost::checked_array_delete(p); - throw; - } - -#else - - pn = new count_type(1); - - if(pn == 0) - { - boost::checked_array_delete(p); - boost::throw_exception(std::bad_alloc()); - } - -#endif - } - - ~shared_array() - { - if(--*pn == 0) - { - boost::checked_array_delete(px); - delete pn; - } - } - - shared_array(shared_array const & r) : px(r.px) // never throws - { - pn = r.pn; - ++*pn; - } - - shared_array & operator=(shared_array const & r) - { - shared_array(r).swap(*this); - return *this; - } - - void reset(T * p = 0) - { - BOOST_ASSERT(p == 0 || p != px); - shared_array(p).swap(*this); - } - - T * get() const // never throws - { - return px; - } - - T & operator[](std::ptrdiff_t i) const // never throws - { - BOOST_ASSERT(px != 0); - BOOST_ASSERT(i >= 0); - return px[i]; - } - - long use_count() const // never throws - { - return *pn; - } - - bool unique() const // never throws - { - return *pn == 1; - } - - void swap(shared_array & other) // never throws - { - std::swap(px, other.px); - std::swap(pn, other.pn); - } - -private: - - T * px; // contained pointer - count_type * pn; // ptr to reference counter - -}; // shared_array - -template inline bool operator==(shared_array const & a, shared_array const & b) -{ - return a.get() == b.get(); -} - -template inline bool operator!=(shared_array const & a, shared_array const & b) -{ - return a.get() != b.get(); -} - -template inline bool operator<(shared_array const & a, shared_array const & b) -{ - return std::less()(a.get(), b.get()); -} - -template void swap(shared_array & a, shared_array & b) -{ - a.swap(b); -} - -} // namespace boost - -#endif // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_count.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_count.hpp index 8e1dd4810..1e7d688c1 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_count.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_count.hpp @@ -225,16 +225,35 @@ class shared_count #endif { typedef sp_counted_impl_pda impl_type; + +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + typedef typename std::allocator_traits::template rebind_alloc< impl_type > A2; + +#else + typedef typename A::template rebind< impl_type >::other A2; +#endif + A2 a2( a ); #ifndef BOOST_NO_EXCEPTIONS try { +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + impl_type * pi = std::allocator_traits::allocate( a2, 1 ); + pi_ = pi; + std::allocator_traits::construct( a2, pi, p, d, a ); + +#else + pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) ); - new( static_cast< void* >( pi_ ) ) impl_type( p, d, a ); + ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a ); + +#endif } catch(...) { @@ -248,13 +267,30 @@ class shared_count throw; } +#else + +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + impl_type * pi = std::allocator_traits::allocate( a2, 1 ); + pi_ = pi; + #else pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) ); +#endif + if( pi_ != 0 ) { - new( static_cast< void* >( pi_ ) ) impl_type( p, d, a ); +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + std::allocator_traits::construct( a2, pi, p, d, a ); + +#else + + ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a ); + +#endif } else { @@ -273,16 +309,35 @@ class shared_count #endif { typedef sp_counted_impl_pda< P, D, A > impl_type; + +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + typedef typename std::allocator_traits::template rebind_alloc< impl_type > A2; + +#else + typedef typename A::template rebind< impl_type >::other A2; +#endif + A2 a2( a ); #ifndef BOOST_NO_EXCEPTIONS try { +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + impl_type * pi = std::allocator_traits::allocate( a2, 1 ); + pi_ = pi; + std::allocator_traits::construct( a2, pi, p, a ); + +#else + pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) ); - new( static_cast< void* >( pi_ ) ) impl_type( p, a ); + ::new( static_cast< void* >( pi_ ) ) impl_type( p, a ); + +#endif } catch(...) { @@ -296,13 +351,30 @@ class shared_count throw; } +#else + +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + impl_type * pi = std::allocator_traits::allocate( a2, 1 ); + pi_ = pi; + #else pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) ); +#endif + if( pi_ != 0 ) { - new( static_cast< void* >( pi_ ) ) impl_type( p, a ); +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + std::allocator_traits::construct( a2, pi, p, a ); + +#else + + ::new( static_cast< void* >( pi_ ) ) impl_type( p, a ); + +#endif } else { diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_ptr_nmt.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_ptr_nmt.hpp deleted file mode 100644 index afc1ec03f..000000000 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/shared_ptr_nmt.hpp +++ /dev/null @@ -1,182 +0,0 @@ -#ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED -#define BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED - -// -// detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates -// -// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. -// Copyright (c) 2001, 2002 Peter Dimov -// -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. -// - -#include -#include -#include -#include - -#ifndef BOOST_NO_AUTO_PTR -# include // for std::auto_ptr -#endif - -#include // for std::swap -#include // for std::less -#include // for std::bad_alloc - -namespace boost -{ - -template class shared_ptr -{ -private: - - typedef detail::atomic_count count_type; - -public: - - typedef T element_type; - typedef T value_type; - - explicit shared_ptr(T * p = 0): px(p) - { -#ifndef BOOST_NO_EXCEPTIONS - - try // prevent leak if new throws - { - pn = new count_type(1); - } - catch(...) - { - boost::checked_delete(p); - throw; - } - -#else - - pn = new count_type(1); - - if(pn == 0) - { - boost::checked_delete(p); - boost::throw_exception(std::bad_alloc()); - } - -#endif - } - - ~shared_ptr() - { - if(--*pn == 0) - { - boost::checked_delete(px); - delete pn; - } - } - - shared_ptr(shared_ptr const & r): px(r.px) // never throws - { - pn = r.pn; - ++*pn; - } - - shared_ptr & operator=(shared_ptr const & r) - { - shared_ptr(r).swap(*this); - return *this; - } - -#ifndef BOOST_NO_AUTO_PTR - - explicit shared_ptr(std::auto_ptr & r) - { - pn = new count_type(1); // may throw - px = r.release(); // fix: moved here to stop leak if new throws - } - - shared_ptr & operator=(std::auto_ptr & r) - { - shared_ptr(r).swap(*this); - return *this; - } - -#endif - - void reset(T * p = 0) - { - BOOST_ASSERT(p == 0 || p != px); - shared_ptr(p).swap(*this); - } - - T & operator*() const // never throws - { - BOOST_ASSERT(px != 0); - return *px; - } - - T * operator->() const // never throws - { - BOOST_ASSERT(px != 0); - return px; - } - - T * get() const // never throws - { - return px; - } - - long use_count() const // never throws - { - return *pn; - } - - bool unique() const // never throws - { - return *pn == 1; - } - - void swap(shared_ptr & other) // never throws - { - std::swap(px, other.px); - std::swap(pn, other.pn); - } - -private: - - T * px; // contained pointer - count_type * pn; // ptr to reference counter -}; - -template inline bool operator==(shared_ptr const & a, shared_ptr const & b) -{ - return a.get() == b.get(); -} - -template inline bool operator!=(shared_ptr const & a, shared_ptr const & b) -{ - return a.get() != b.get(); -} - -template inline bool operator<(shared_ptr const & a, shared_ptr const & b) -{ - return std::less()(a.get(), b.get()); -} - -template void swap(shared_ptr & a, shared_ptr & b) -{ - a.swap(b); -} - -// get_pointer() enables boost::mem_fn to recognize shared_ptr - -template inline T * get_pointer(shared_ptr const & p) -{ - return p.get(); -} - -} // namespace boost - -#endif // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base.hpp index 9ced2b95e..c4158920e 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base.hpp @@ -10,7 +10,7 @@ // // detail/sp_counted_base.hpp // -// Copyright 2005, 2006 Peter Dimov +// Copyright 2005-2013 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at @@ -23,6 +23,9 @@ #if defined( BOOST_SP_DISABLE_THREADS ) # include +#elif defined( BOOST_SP_USE_STD_ATOMIC ) +# include + #elif defined( BOOST_SP_USE_SPINLOCK ) # include diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_pt.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_pt.hpp index a742c3df5..a16d2d865 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_pt.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_pt.hpp @@ -19,6 +19,7 @@ // #include +#include #include namespace boost @@ -46,15 +47,15 @@ class sp_counted_base // HPUX 10.20 / DCE has a nonstandard pthread_mutex_init #if defined(__hpux) && defined(_DECTHREADS_) - pthread_mutex_init( &m_, pthread_mutexattr_default ); + BOOST_VERIFY( pthread_mutex_init( &m_, pthread_mutexattr_default ) == 0 ); #else - pthread_mutex_init( &m_, 0 ); + BOOST_VERIFY( pthread_mutex_init( &m_, 0 ) == 0 ); #endif } virtual ~sp_counted_base() // nothrow { - pthread_mutex_destroy( &m_ ); + BOOST_VERIFY( pthread_mutex_destroy( &m_ ) == 0 ); } // dispose() is called when use_count_ drops to zero, to release @@ -74,24 +75,24 @@ class sp_counted_base void add_ref_copy() { - pthread_mutex_lock( &m_ ); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); ++use_count_; - pthread_mutex_unlock( &m_ ); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); } bool add_ref_lock() // true on success { - pthread_mutex_lock( &m_ ); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); bool r = use_count_ == 0? false: ( ++use_count_, true ); - pthread_mutex_unlock( &m_ ); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); return r; } void release() // nothrow { - pthread_mutex_lock( &m_ ); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); long new_use_count = --use_count_; - pthread_mutex_unlock( &m_ ); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); if( new_use_count == 0 ) { @@ -102,16 +103,16 @@ class sp_counted_base void weak_add_ref() // nothrow { - pthread_mutex_lock( &m_ ); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); ++weak_count_; - pthread_mutex_unlock( &m_ ); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); } void weak_release() // nothrow { - pthread_mutex_lock( &m_ ); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); long new_weak_count = --weak_count_; - pthread_mutex_unlock( &m_ ); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); if( new_weak_count == 0 ) { @@ -121,9 +122,9 @@ class sp_counted_base long use_count() const // nothrow { - pthread_mutex_lock( &m_ ); + BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 ); long r = use_count_; - pthread_mutex_unlock( &m_ ); + BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 ); return r; } diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp new file mode 100644 index 000000000..cab845359 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp @@ -0,0 +1,137 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/sp_counted_base_std_atomic.hpp - C++11 std::atomic +// +// Copyright (c) 2007, 2013 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt + +#include +#include +#include + +namespace boost +{ + +namespace detail +{ + +inline void atomic_increment( std::atomic_int_least32_t * pw ) +{ + pw->fetch_add( 1, std::memory_order_relaxed ); +} + +inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw ) +{ + return pw->fetch_sub( 1, std::memory_order_acq_rel ); +} + +inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw ) +{ + // long r = *pw; + // if( r != 0 ) ++*pw; + // return r; + + std::int_least32_t r = pw->load( std::memory_order_relaxed ); + + for( ;; ) + { + if( r == 0 ) + { + return r; + } + + if( pw->compare_exchange_weak( r, r + 1, std::memory_order_relaxed, std::memory_order_relaxed ) ) + { + return r; + } + } +} + +class sp_counted_base +{ +private: + + sp_counted_base( sp_counted_base const & ); + sp_counted_base & operator= ( sp_counted_base const & ); + + std::atomic_int_least32_t use_count_; // #shared + std::atomic_int_least32_t weak_count_; // #weak + (#shared != 0) + +public: + + sp_counted_base(): use_count_( 1 ), weak_count_( 1 ) + { + } + + virtual ~sp_counted_base() // nothrow + { + } + + // dispose() is called when use_count_ drops to zero, to release + // the resources managed by *this. + + virtual void dispose() = 0; // nothrow + + // destroy() is called when weak_count_ drops to zero. + + virtual void destroy() // nothrow + { + delete this; + } + + virtual void * get_deleter( sp_typeinfo const & ti ) = 0; + virtual void * get_untyped_deleter() = 0; + + void add_ref_copy() + { + atomic_increment( &use_count_ ); + } + + bool add_ref_lock() // true on success + { + return atomic_conditional_increment( &use_count_ ) != 0; + } + + void release() // nothrow + { + if( atomic_decrement( &use_count_ ) == 1 ) + { + dispose(); + weak_release(); + } + } + + void weak_add_ref() // nothrow + { + atomic_increment( &weak_count_ ); + } + + void weak_release() // nothrow + { + if( atomic_decrement( &weak_count_ ) == 1 ) + { + destroy(); + } + } + + long use_count() const // nothrow + { + return use_count_.load( std::memory_order_acquire ); + } +}; + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_w32.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_w32.hpp index ff394dc6b..4ba509c6c 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_w32.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_base_w32.hpp @@ -24,7 +24,7 @@ // formulation // -#include +#include #include #include @@ -71,7 +71,7 @@ class sp_counted_base void add_ref_copy() { - BOOST_INTERLOCKED_INCREMENT( &use_count_ ); + BOOST_SP_INTERLOCKED_INCREMENT( &use_count_ ); } bool add_ref_lock() // true on success @@ -86,11 +86,11 @@ class sp_counted_base // work around a code generation bug long tmp2 = tmp + 1; - if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true; + if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true; #else - if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true; + if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true; #endif } @@ -98,7 +98,7 @@ class sp_counted_base void release() // nothrow { - if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 ) + if( BOOST_SP_INTERLOCKED_DECREMENT( &use_count_ ) == 0 ) { dispose(); weak_release(); @@ -107,12 +107,12 @@ class sp_counted_base void weak_add_ref() // nothrow { - BOOST_INTERLOCKED_INCREMENT( &weak_count_ ); + BOOST_SP_INTERLOCKED_INCREMENT( &weak_count_ ); } void weak_release() // nothrow { - if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 ) + if( BOOST_SP_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 ) { destroy(); } diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_impl.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_impl.hpp index d15cd3cf1..a7b43aeaf 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_impl.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_counted_impl.hpp @@ -213,7 +213,7 @@ template class sp_counted_impl_pda: public sp_counted { } - sp_counted_impl_pda( P p, A a ): p_( p ), d_(), a_( a ) + sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a ) { } @@ -224,11 +224,28 @@ template class sp_counted_impl_pda: public sp_counted virtual void destroy() // nothrow { +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + typedef typename std::allocator_traits::template rebind_alloc< this_type > A2; + +#else + typedef typename A::template rebind< this_type >::other A2; +#endif + A2 a2( a_ ); +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + std::allocator_traits::destroy( a2, this ); + +#else + this->~this_type(); + +#endif + a2.deallocate( this, 1 ); } diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_if_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_if_array.hpp index 661e1785e..9a2c1e0ba 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_if_array.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_if_array.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012 Glen Joseph Fernandes + * Copyright (c) 2012-2014 Glen Joseph Fernandes * glenfe at live dot com * * Distributed under the Boost Software License, @@ -13,15 +13,18 @@ namespace boost { namespace detail { - template + template struct sp_if_array; - template + + template struct sp_if_array { typedef boost::shared_ptr type; }; - template + + template struct sp_if_size_array; - template + + template struct sp_if_size_array { typedef boost::shared_ptr type; }; diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_interlocked.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_interlocked.hpp new file mode 100644 index 000000000..814b0c2e9 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/sp_interlocked.hpp @@ -0,0 +1,152 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/sp_interlocked.hpp +// +// Copyright 2005, 2014 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// + +#include + +// BOOST_SP_HAS_INTRIN_H + +// VC9 has intrin.h, but it collides with +#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600 + +# define BOOST_SP_HAS_INTRIN_H + +// Unlike __MINGW64__, __MINGW64_VERSION_MAJOR is defined by MinGW-w64 for both 32 and 64-bit targets. +#elif defined( __MINGW64_VERSION_MAJOR ) + +// MinGW-w64 provides intrin.h for both 32 and 64-bit targets. +# define BOOST_SP_HAS_INTRIN_H + +// Intel C++ on Windows on VC10+ stdlib +#elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520 + +# define BOOST_SP_HAS_INTRIN_H + +#endif + +#if defined( BOOST_USE_WINDOWS_H ) + +# include + +# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd + +#elif defined( BOOST_USE_INTRIN_H ) || defined( BOOST_SP_HAS_INTRIN_H ) + +#include + +# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#elif defined( _WIN32_WCE ) + +#if _WIN32_WCE >= 0x600 + +extern "C" long __cdecl _InterlockedIncrement( long volatile * ); +extern "C" long __cdecl _InterlockedDecrement( long volatile * ); +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); + +# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#else + +// under Windows CE we still have old-style Interlocked* functions + +extern "C" long __cdecl InterlockedIncrement( long* ); +extern "C" long __cdecl InterlockedDecrement( long* ); +extern "C" long __cdecl InterlockedCompareExchange( long*, long, long ); +extern "C" long __cdecl InterlockedExchange( long*, long ); +extern "C" long __cdecl InterlockedExchangeAdd( long*, long ); + +# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd + +#endif + +#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN ) + +#if defined( __CLRCALL_PURE_OR_CDECL ) + +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long ); + +#else + +extern "C" long __cdecl _InterlockedIncrement( long volatile * ); +extern "C" long __cdecl _InterlockedDecrement( long volatile * ); +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); + +#endif + +# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ ) + +namespace boost +{ + +namespace detail +{ + +extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * ); +extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * ); +extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long ); +extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long ); +extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long ); + +} // namespace detail + +} // namespace boost + +# define BOOST_SP_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd + +#else + +# error "Interlocked intrinsics not available" + +#endif + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock.hpp index 88d7ad62c..19f93d7c6 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock.hpp @@ -31,7 +31,16 @@ #include #include -#if defined( BOOST_SP_USE_PTHREADS ) +#if defined( BOOST_SP_USE_STD_ATOMIC ) +# if !defined( __clang__ ) +# include +# else +// Clang (at least up to 3.4) can't compile spinlock_pool when +// using std::atomic, so substitute the __sync implementation instead. +# include +# endif + +#elif defined( BOOST_SP_USE_PTHREADS ) # include #elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ ) diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_std_atomic.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_std_atomic.hpp new file mode 100644 index 000000000..a61c1cd96 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_std_atomic.hpp @@ -0,0 +1,83 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// Copyright (c) 2014 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#include +#include + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + std::atomic_flag v_; + +public: + + bool try_lock() + { + return !v_.test_and_set( std::memory_order_acquire ); + } + + void lock() + { + for( unsigned k = 0; !try_lock(); ++k ) + { + boost::detail::yield( k ); + } + } + + void unlock() + { + v_ .clear( std::memory_order_release ); + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ): sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT { ATOMIC_FLAG_INIT } + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_w32.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_w32.hpp index fb97629c7..d34e4fc2b 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_w32.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/spinlock_w32.hpp @@ -15,7 +15,7 @@ // http://www.boost.org/LICENSE_1_0.txt) // -#include +#include #include // BOOST_COMPILER_FENCE @@ -59,7 +59,7 @@ class spinlock bool try_lock() { - long r = BOOST_INTERLOCKED_EXCHANGE( &v_, 1 ); + long r = BOOST_SP_INTERLOCKED_EXCHANGE( &v_, 1 ); BOOST_COMPILER_FENCE diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/up_if_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/up_if_array.hpp new file mode 100644 index 000000000..7e62d106b --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/up_if_array.hpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_DETAIL_UP_IF_ARRAY_HPP +#define BOOST_SMART_PTR_DETAIL_UP_IF_ARRAY_HPP + +#include + +namespace boost { + namespace detail { + template + struct up_if_array; + + template + struct up_if_array { + typedef std::unique_ptr type; + }; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/up_if_not_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/up_if_not_array.hpp new file mode 100644 index 000000000..fd74f2531 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/up_if_not_array.hpp @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_DETAIL_UP_IF_NOT_ARRAY_HPP +#define BOOST_SMART_PTR_DETAIL_UP_IF_NOT_ARRAY_HPP + +#include + +namespace boost { + namespace detail { + template + struct up_if_not_array { + typedef std::unique_ptr type; + }; + + template + struct up_if_not_array { + }; + + template + struct up_if_not_array { + }; + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/detail/yield_k.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/detail/yield_k.hpp index 14af52494..9f4496b98 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/detail/yield_k.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/detail/yield_k.hpp @@ -11,6 +11,7 @@ // yield_k.hpp // // Copyright (c) 2008 Peter Dimov +// Copyright (c) Microsoft Corporation 2014 // // void yield( unsigned k ); // @@ -24,6 +25,11 @@ // #include +#include + +#if BOOST_PLAT_WINDOWS_RUNTIME +#include +#endif // BOOST_SMT_PAUSE @@ -53,7 +59,7 @@ namespace boost namespace detail { -#if !defined( BOOST_USE_WINDOWS_H ) +#if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME extern "C" void __stdcall Sleep( unsigned long ms ); #endif @@ -68,6 +74,7 @@ inline void yield( unsigned k ) BOOST_SMT_PAUSE } #endif +#if !BOOST_PLAT_WINDOWS_RUNTIME else if( k < 32 ) { Sleep( 0 ); @@ -76,6 +83,13 @@ inline void yield( unsigned k ) { Sleep( 1 ); } +#else + else + { + // Sleep isn't supported on the Windows Runtime. + std::this_thread::yield(); + } +#endif } } // namespace detail diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/intrusive_ptr.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/intrusive_ptr.hpp index b6f5bcd53..e5db60997 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/intrusive_ptr.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/intrusive_ptr.hpp @@ -146,11 +146,23 @@ template class intrusive_ptr this_type( rhs ).swap( *this ); } + void reset( T * rhs, bool add_ref ) + { + this_type( rhs, add_ref ).swap( *this ); + } + T * get() const BOOST_NOEXCEPT { return px; } + T * detach() BOOST_NOEXCEPT + { + T * ret = px; + px = 0; + return ret; + } + T & operator*() const { BOOST_ASSERT( px != 0 ); diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_array.hpp index eb0578d9f..c48f5070b 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_array.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_array.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012 Glen Joseph Fernandes + * Copyright (c) 2012-2014 Glen Joseph Fernandes * glenfe at live dot com * * Distributed under the Boost Software License, @@ -9,238 +9,149 @@ #ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP #define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP -#include -#include -#include -#include +#include #include -#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) -#include -#endif namespace boost { - template + template inline typename boost::detail::sp_if_array::type make_shared(std::size_t size) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; - T1* p1 = 0; - T2* p2 = 0; + typedef boost::detail::ms_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::make_array_helper a1(n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2); - return boost::shared_ptr(s1, p1); - } -#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - template - inline typename boost::detail::sp_if_array::type - make_shared(std::size_t size, Args&&... args) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - T1* p1 = 0; - T2* p2 = 0; - std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::make_array_helper a1(n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(args)...); - return boost::shared_ptr(s1, p1); - } - template - inline typename boost::detail::sp_if_size_array::type - make_shared(Args&&... args) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - enum { - N = boost::detail::array_total::size - }; T1* p1 = 0; T2* p2 = 0; - boost::detail::make_array_helper a1(&p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + D1 d1; + A1 a1(size, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_init(p2, n1); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(args)...); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } -#endif -#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) - template + + template inline typename boost::detail::sp_if_size_array::type - make_shared(const T& list) { + make_shared() { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; - typedef const T2 T3; + typedef boost::detail::ms_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { N = boost::detail::array_total::size }; T1* p1 = 0; T2* p2 = 0; - T3* p3 = 0; - boost::detail::make_array_helper a1(&p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list); + D1 d1; + A1 a1(&p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_init(p2, N); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init_list(p2, p3); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_array::type make_shared(std::size_t size, - const typename boost::detail::array_inner::type& list) { + const typename boost::detail::array_inner::type& value) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; typedef const T2 T3; + typedef boost::detail::ms_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { M = boost::detail::array_total::size }; + std::size_t n1 = M * size; T1* p1 = 0; T2* p2 = 0; - T3* p3 = 0; - std::size_t n1 = M * size; - boost::detail::make_array_helper a1(n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list); + T3* p3 = reinterpret_cast(&value); + D1 d1; + A1 a1(size, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_init(p2, n1, p3); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->template init_list(p2, p3); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_size_array::type - make_shared(const typename boost::detail::array_inner::type& list) { + make_shared(const typename boost::detail::array_inner::type& value) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; typedef const T2 T3; + typedef boost::detail::ms_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { M = boost::detail::array_total::size, N = boost::detail::array_total::size }; T1* p1 = 0; T2* p2 = 0; - T3* p3 = 0; - boost::detail::make_array_helper a1(&p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list); - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->template init_list(p2, p3); - return boost::shared_ptr(s1, p1); - } -#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) - template - inline typename boost::detail::sp_if_array::type - make_shared(std::initializer_list::type> list) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - typedef const T2 T3; - T1* p1 = 0; - T2* p2 = 0; - T3* p3 = 0; - std::size_t n1 = list.size() * boost::detail::array_total::size; - boost::detail::make_array_helper a1(n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p3 = reinterpret_cast(list.begin()); - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init_list(p2, p3); - return boost::shared_ptr(s1, p1); - } -#endif -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - template - inline typename boost::detail::sp_if_array::type - make_shared(std::size_t size, - typename boost::detail::array_base::type&& value) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - T1* p1 = 0; - T2* p2 = 0; - std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::make_array_helper a1(n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; - p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(value)); - return boost::shared_ptr(s1, p1); - } - template - inline typename boost::detail::sp_if_size_array::type - make_shared(typename boost::detail::array_base::type&& value) { - typedef typename boost::detail::array_inner::type T1; - typedef typename boost::detail::array_base::type T2; - enum { - N = boost::detail::array_total::size - }; - T1* p1 = 0; - T2* p2 = 0; - boost::detail::make_array_helper a1(&p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + T3* p3 = reinterpret_cast(&value); + D1 d1; + A1 a1(&p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_init(p2, N, p3); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->init(p2, boost::detail::sp_forward(value)); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } -#endif -#endif - template + + template inline typename boost::detail::sp_if_array::type make_shared_noinit(std::size_t size) { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; + typedef boost::detail::ms_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; + std::size_t n1 = size * boost::detail::array_total::size; T1* p1 = 0; T2* p2 = 0; - std::size_t n1 = size * boost::detail::array_total::size; - boost::detail::make_array_helper a1(n1, &p2); - boost::detail::array_deleter d1(n1); - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + D1 d1; + A1 a1(size, &p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_noinit(p2, n1); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->noinit(p2); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } - template + + template inline typename boost::detail::sp_if_size_array::type make_shared_noinit() { typedef typename boost::detail::array_inner::type T1; typedef typename boost::detail::array_base::type T2; + typedef boost::detail::ms_allocator A1; + typedef boost::detail::ms_in_allocator_tag D1; enum { N = boost::detail::array_total::size }; T1* p1 = 0; T2* p2 = 0; - boost::detail::make_array_helper a1(&p2); - boost::detail::array_deleter d1; - boost::shared_ptr s1(p1, d1, a1); - typedef boost::detail::array_deleter* D2; + D1 d1; + A1 a1(&p2); + shared_ptr s1(p1, d1, a1); + A1* a2 = static_cast(s1._internal_get_untyped_deleter()); + a2->set(0); + boost::detail::ms_noinit(p2, N); + a2->set(p2); p1 = reinterpret_cast(p2); - D2 d2 = static_cast(s1._internal_get_untyped_deleter()); - d2->noinit(p2); - return boost::shared_ptr(s1, p1); + return shared_ptr(s1, p1); } } diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_object.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_object.hpp index 52a00cecd..62372fa7e 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_object.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/make_shared_object.hpp @@ -72,6 +72,10 @@ template< class T > class sp_ms_deleter { } + template explicit sp_ms_deleter( A const & ) BOOST_NOEXCEPT : initialized_( false ) + { + } + // optimization: do not copy storage_ sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false ) { @@ -102,6 +106,74 @@ template< class T > class sp_ms_deleter } }; +template< class T, class A > class sp_as_deleter +{ +private: + + typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type; + + storage_type storage_; + A a_; + bool initialized_; + +private: + + void destroy() + { + if( initialized_ ) + { + T * p = reinterpret_cast< T* >( storage_.data_ ); + +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + std::allocator_traits::destroy( a_, p ); + +#else + + p->~T(); + +#endif + + initialized_ = false; + } + } + +public: + + sp_as_deleter( A const & a ) BOOST_NOEXCEPT : a_( a ), initialized_( false ) + { + } + + // optimization: do not copy storage_ + sp_as_deleter( sp_as_deleter const & r ) BOOST_NOEXCEPT : a_( r.a_), initialized_( false ) + { + } + + ~sp_as_deleter() + { + destroy(); + } + + void operator()( T * ) + { + destroy(); + } + + static void operator_fn( T* ) // operator() can't be static + { + } + + void * address() BOOST_NOEXCEPT + { + return storage_.data_; + } + + void set_initialized() BOOST_NOEXCEPT + { + initialized_ = true; + } +}; + template< class T > struct sp_if_not_array { typedef boost::shared_ptr< T > type; @@ -131,11 +203,9 @@ template< class T, std::size_t N > struct sp_if_not_array< T[N] > # define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >() #endif -// Zero-argument versions -// -// Used even when variadic templates are available because of the new T() vs new T issue +// _noinit versions -template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared() +template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit() { boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) ); @@ -143,7 +213,7 @@ template< class T > typename boost::detail::sp_if_not_array< T >::type make_shar void * pv = pd->address(); - ::new( pv ) T(); + ::new( pv ) T; pd->set_initialized(); T * pt2 = static_cast< T* >( pv ); @@ -152,9 +222,9 @@ template< class T > typename boost::detail::sp_if_not_array< T >::type make_shar return boost::shared_ptr< T >( pt, pt2 ); } -template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit() +template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a ) { - boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) ); + boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a ); boost::detail::sp_ms_deleter< T > * pd = static_cast *>( pt._internal_get_untyped_deleter() ); @@ -169,15 +239,19 @@ template< class T > typename boost::detail::sp_if_not_array< T >::type make_shar return boost::shared_ptr< T >( pt, pt2 ); } -template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a ) +#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +// Variadic templates, rvalue reference + +template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args ) { - boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a ); + boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) ); boost::detail::sp_ms_deleter< T > * pd = static_cast *>( pt._internal_get_untyped_deleter() ); void * pv = pd->address(); - ::new( pv ) T(); + ::new( pv ) T( boost::detail::sp_forward( args )... ); pd->set_initialized(); T * pt2 = static_cast< T* >( pv ); @@ -186,15 +260,38 @@ template< class T, class A > typename boost::detail::sp_if_not_array< T >::type return boost::shared_ptr< T >( pt, pt2 ); } -template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a ) +template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args ) { - boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a ); +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) - boost::detail::sp_ms_deleter< T > * pd = static_cast *>( pt._internal_get_untyped_deleter() ); + typedef typename std::allocator_traits::template rebind_alloc A2; + A2 a2( a ); + + typedef boost::detail::sp_as_deleter< T, A2 > D; + + boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag(), a2 ); + +#else + + typedef boost::detail::sp_ms_deleter< T > D; + boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag(), a ); + +#endif + + D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() ); void * pv = pd->address(); - ::new( pv ) T; +#if !defined( BOOST_NO_CXX11_ALLOCATOR ) + + std::allocator_traits::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward( args )... ); + +#else + + ::new( pv ) T( boost::detail::sp_forward( args )... ); + +#endif + pd->set_initialized(); T * pt2 = static_cast< T* >( pv ); @@ -203,11 +300,11 @@ template< class T, class A > typename boost::detail::sp_if_not_array< T >::type return boost::shared_ptr< T >( pt, pt2 ); } -#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) +#else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) -// Variadic templates, rvalue reference +// Common zero-argument versions -template< class T, class Arg1, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Arg1 && arg1, Args && ... args ) +template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared() { boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) ); @@ -215,7 +312,7 @@ template< class T, class Arg1, class... Args > typename boost::detail::sp_if_not void * pv = pd->address(); - ::new( pv ) T( boost::detail::sp_forward( arg1 ), boost::detail::sp_forward( args )... ); + ::new( pv ) T(); pd->set_initialized(); T * pt2 = static_cast< T* >( pv ); @@ -224,7 +321,7 @@ template< class T, class Arg1, class... Args > typename boost::detail::sp_if_not return boost::shared_ptr< T >( pt, pt2 ); } -template< class T, class A, class Arg1, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Arg1 && arg1, Args && ... args ) +template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a ) { boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a ); @@ -232,7 +329,7 @@ template< class T, class A, class Arg1, class... Args > typename boost::detail:: void * pv = pd->address(); - ::new( pv ) T( boost::detail::sp_forward( arg1 ), boost::detail::sp_forward( args )... ); + ::new( pv ) T(); pd->set_initialized(); T * pt2 = static_cast< T* >( pv ); @@ -241,7 +338,7 @@ template< class T, class A, class Arg1, class... Args > typename boost::detail:: return boost::shared_ptr< T >( pt, pt2 ); } -#elif !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) // For example MSVC 10.0 @@ -695,7 +792,7 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, return boost::shared_ptr< T >( pt, pt2 ); } -#else +#else // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) // C++03 version @@ -1023,7 +1120,9 @@ typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, return boost::shared_ptr< T >( pt, pt2 ); } -#endif +#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +#endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) #undef BOOST_SP_MSD diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/make_unique.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/make_unique.hpp new file mode 100644 index 000000000..90402e2ba --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/make_unique.hpp @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP +#define BOOST_SMART_PTR_MAKE_UNIQUE_HPP + +#include +#include + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/make_unique_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/make_unique_array.hpp new file mode 100644 index 000000000..eb0528e63 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/make_unique_array.hpp @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_MAKE_UNIQUE_ARRAY_HPP +#define BOOST_SMART_PTR_MAKE_UNIQUE_ARRAY_HPP + +#include +#include + +namespace boost { + template + inline typename boost::detail::up_if_array::type + make_unique(std::size_t size) { + typedef typename boost::detail::array_inner::type U; + return std::unique_ptr(new U[size]()); + } + + template + inline typename boost::detail::up_if_array::type + make_unique_noinit(std::size_t size) { + typedef typename boost::detail::array_inner::type U; + return std::unique_ptr(new U[size]); + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/make_unique_object.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/make_unique_object.hpp new file mode 100644 index 000000000..9e6108a36 --- /dev/null +++ b/src/thirdparty/boost_lib/boost/smart_ptr/make_unique_object.hpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2014 Glen Joseph Fernandes + * glenfe at live dot com + * + * Distributed under the Boost Software License, + * Version 1.0. (See accompanying file LICENSE_1_0.txt + * or copy at http://boost.org/LICENSE_1_0.txt) + */ +#ifndef BOOST_SMART_PTR_MAKE_UNIQUE_OBJECT_HPP +#define BOOST_SMART_PTR_MAKE_UNIQUE_OBJECT_HPP + +#include +#include +#include +#include + +namespace boost { + template + inline typename boost::detail::up_if_not_array::type + make_unique() { + return std::unique_ptr(new T()); + } + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + template + inline typename boost::detail::up_if_not_array::type + make_unique(Args&&... args) { + return std::unique_ptr(new T(std::forward(args)...)); + } +#endif + + template + inline typename boost::detail::up_if_not_array::type + make_unique(typename add_rvalue_reference::type value) { + return std::unique_ptr(new T(std::move(value))); + } + + template + inline typename boost::detail::up_if_not_array::type + make_unique_noinit() { + return std::unique_ptr(new T); + } +} + +#endif diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/shared_array.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/shared_array.hpp index 73a07ae1b..fd58071be 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/shared_array.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/shared_array.hpp @@ -16,10 +16,6 @@ #include // for broken compiler workarounds -#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) -#include -#else - #include // TR1 cyclic inclusion fix #include @@ -61,6 +57,14 @@ template class shared_array { } +#if !defined( BOOST_NO_CXX11_NULLPTR ) + + shared_array( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT : px( 0 ), pn() + { + } + +#endif + template explicit shared_array( Y * p ): px( p ), pn( p, checked_array_deleter() ) { @@ -285,6 +289,4 @@ template< class D, class T > D * get_deleter( shared_array const & p ) } // namespace boost -#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) - #endif // #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/smart_ptr/shared_ptr.hpp b/src/thirdparty/boost_lib/boost/smart_ptr/shared_ptr.hpp index 9259ca0f0..83b0451e8 100644 --- a/src/thirdparty/boost_lib/boost/smart_ptr/shared_ptr.hpp +++ b/src/thirdparty/boost_lib/boost/smart_ptr/shared_ptr.hpp @@ -16,10 +16,6 @@ #include // for broken compiler workarounds -#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) -#include -#else - // In order to avoid circular dependencies with Boost.TR1 // we make sure that our include of doesn't try to // pull in the TR1 headers: that's why we use this header @@ -36,7 +32,6 @@ #if !defined(BOOST_SP_NO_ATOMIC_ACCESS) #include -#include #endif #include // for std::swap @@ -955,7 +950,7 @@ template shared_ptr atomic_load( shared_ptr const * p ) return *p; } -template inline shared_ptr atomic_load_explicit( shared_ptr const * p, memory_order /*mo*/ ) +template inline shared_ptr atomic_load_explicit( shared_ptr const * p, /*memory_order mo*/ int ) { return atomic_load( p ); } @@ -966,7 +961,7 @@ template void atomic_store( shared_ptr * p, shared_ptr r ) p->swap( r ); } -template inline void atomic_store_explicit( shared_ptr * p, shared_ptr r, memory_order /*mo*/ ) +template inline void atomic_store_explicit( shared_ptr * p, shared_ptr r, /*memory_order mo*/ int ) { atomic_store( p, r ); // std::move( r ) } @@ -982,7 +977,7 @@ template shared_ptr atomic_exchange( shared_ptr * p, shared_ptr shared_ptr atomic_exchange_explicit( shared_ptr * p, shared_ptr r, memory_order /*mo*/ ) +template shared_ptr atomic_exchange_explicit( shared_ptr * p, shared_ptr r, /*memory_order mo*/ int ) { return atomic_exchange( p, r ); // std::move( r ) } @@ -1012,7 +1007,7 @@ template bool atomic_compare_exchange( shared_ptr * p, shared_ptr } } -template inline bool atomic_compare_exchange_explicit( shared_ptr * p, shared_ptr * v, shared_ptr w, memory_order /*success*/, memory_order /*failure*/ ) +template inline bool atomic_compare_exchange_explicit( shared_ptr * p, shared_ptr * v, shared_ptr w, /*memory_order success*/ int, /*memory_order failure*/ int ) { return atomic_compare_exchange( p, v, w ); // std::move( w ) } @@ -1030,6 +1025,4 @@ template< class T > std::size_t hash_value( boost::shared_ptr const & p ) BOO } // namespace boost -#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) - #endif // #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/spirit.hpp b/src/thirdparty/boost_lib/boost/spirit.hpp index 7de49e68b..7250ec158 100644 --- a/src/thirdparty/boost_lib/boost/spirit.hpp +++ b/src/thirdparty/boost_lib/boost/spirit.hpp @@ -1,6 +1,6 @@ /*============================================================================= Copyright (c) 2001-2008 Joel de Guzman - Copyright (c) 2001-2009 Hartmut Kaiser + Copyright (c) 2001-2008 Hartmut Kaiser http://spirit.sourceforge.net/ Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/src/thirdparty/boost_lib/boost/strong_typedef.hpp b/src/thirdparty/boost_lib/boost/strong_typedef.hpp index a8d870a53..7d85b1e55 100644 --- a/src/thirdparty/boost_lib/boost/strong_typedef.hpp +++ b/src/thirdparty/boost_lib/boost/strong_typedef.hpp @@ -2,7 +2,7 @@ #define BOOST_STRONG_TYPEDEF_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif diff --git a/src/thirdparty/boost_lib/boost/swap.hpp b/src/thirdparty/boost_lib/boost/swap.hpp index dfc11f059..55cafa4fd 100644 --- a/src/thirdparty/boost_lib/boost/swap.hpp +++ b/src/thirdparty/boost_lib/boost/swap.hpp @@ -1,12 +1,17 @@ -// Copyright (C) 2007 Joseph Gauterin -// -// 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) +/* + * Copyright (c) 2014 Glen Fernandes + * + * Distributed under the Boost Software License, Version 1.0. (See + * accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ #ifndef BOOST_SWAP_HPP #define BOOST_SWAP_HPP -#include "boost/utility/swap.hpp" +// The header file at this path is deprecated; +// use boost/core/swap.hpp instead. + +#include #endif diff --git a/src/thirdparty/boost_lib/boost/throw_exception.hpp b/src/thirdparty/boost_lib/boost/throw_exception.hpp index 200683ec2..aa977dfc7 100644 --- a/src/thirdparty/boost_lib/boost/throw_exception.hpp +++ b/src/thirdparty/boost_lib/boost/throw_exception.hpp @@ -26,7 +26,6 @@ // http://www.boost.org/libs/utility/throw_exception.html // -#include #include #include #include @@ -60,7 +59,7 @@ void throw_exception( std::exception const & e ); // user defined inline void throw_exception_assert_compatibility( std::exception const & ) { } -template BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const & e ) +template BOOST_NORETURN inline void throw_exception( E const & e ) { //All boost exceptions are required to derive from std::exception, //to ensure compatibility with BOOST_NO_EXCEPTIONS. @@ -80,7 +79,7 @@ template BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const exception_detail { template - BOOST_ATTRIBUTE_NORETURN + BOOST_NORETURN void throw_exception_( E const & x, char const * current_function, char const * file, int line ) { diff --git a/src/thirdparty/boost_lib/boost/token_functions.hpp b/src/thirdparty/boost_lib/boost/token_functions.hpp index 98ea80b00..33b37cd84 100644 --- a/src/thirdparty/boost_lib/boost/token_functions.hpp +++ b/src/thirdparty/boost_lib/boost/token_functions.hpp @@ -278,22 +278,7 @@ namespace boost{ struct assign_or_plus_equal { template static void assign(Iterator b, Iterator e, Token &t) { - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) &&\ - BOOST_WORKAROUND(__SGI_STL_PORT, < 0x500) &&\ - defined(_STLP_DEBUG) &&\ - (defined(_STLP_USE_DYNAMIC_LIB) || defined(_DLL)) - // Problem with string::assign for msvc-stlport in debug mode: the - // linker tries to import the templatized version of this memfun, - // which is obviously not exported. - // See http://www.stlport.com/dcforum/DCForumID6/1763.html for details. - - t = Token(); - while(b != e) t += *b++; -#else t.assign(b, e); -#endif - } template diff --git a/src/thirdparty/boost_lib/boost/token_iterator.hpp b/src/thirdparty/boost_lib/boost/token_iterator.hpp index 19b1db26c..929fad620 100644 --- a/src/thirdparty/boost_lib/boost/token_iterator.hpp +++ b/src/thirdparty/boost_lib/boost/token_iterator.hpp @@ -34,7 +34,7 @@ namespace boost , typename detail::minimum_category< forward_traversal_tag , typename iterator_traversal::type - >::type + >::type , const Type& > { @@ -88,7 +88,7 @@ namespace boost Iterator base()const{return begin_;} - Iterator end()const{return end_;}; + Iterator end()const{return end_;} TokenizerFunc tokenizer_function()const{return f_;} @@ -101,24 +101,24 @@ namespace boost }; template < - class TokenizerFunc = char_delimiters_separator, + class TokenizerFunc = char_delimiters_separator, class Iterator = std::string::const_iterator, class Type = std::string > class token_iterator_generator { - private: + private: public: typedef token_iterator type; }; - - + + // Type has to be first because it needs to be explicitly specified // because there is no way the function can deduce it. template - typename token_iterator_generator::type + typename token_iterator_generator::type make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){ - typedef typename + typedef typename token_iterator_generator::type ret_type; return ret_type(fun,begin,end); } diff --git a/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic.hpp b/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic.hpp index 88f0d9023..5f26c7fdc 100644 --- a/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic.hpp +++ b/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic.hpp @@ -41,6 +41,11 @@ #include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND +#if BOOST_GCC >= 40700 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-local-typedefs" +#endif + namespace boost { namespace tuples { @@ -208,7 +213,7 @@ template inline typename access_traits< typename element >::type >::non_const_type -get(cons& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { +get(cons& c) { typedef BOOST_DEDUCED_TYPENAME detail::drop_front::BOOST_NESTED_TEMPLATE apply > impl; typedef BOOST_DEDUCED_TYPENAME impl::type cons_element; @@ -222,10 +227,9 @@ template inline typename access_traits< typename element >::type >::const_type -get(const cons& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { +get(const cons& c) { typedef BOOST_DEDUCED_TYPENAME detail::drop_front::BOOST_NESTED_TEMPLATE apply > impl; - typedef BOOST_DEDUCED_TYPENAME impl::type cons_element; return impl::call(c).head; } @@ -399,7 +403,7 @@ struct cons { typename access_traits< typename element::type >::non_const_type - get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { + get() { return boost::tuples::get(*this); } @@ -407,7 +411,7 @@ struct cons { typename access_traits< typename element::type >::const_type - get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const { + get() const { return boost::tuples::get(*this); } @@ -975,6 +979,11 @@ inline void swap(tuple& lhs, } // end of namespace boost +#if BOOST_GCC >= 40700 +#pragma GCC diagnostic pop +#endif + + #endif // BOOST_TUPLE_BASIC_HPP diff --git a/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic_no_partial_spec.hpp b/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic_no_partial_spec.hpp deleted file mode 100644 index 7379bf818..000000000 --- a/src/thirdparty/boost_lib/boost/tuple/detail/tuple_basic_no_partial_spec.hpp +++ /dev/null @@ -1,865 +0,0 @@ -// - tuple_basic_no_partial_spec.hpp ----------------------------------------- - -// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu) -// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) -// -// 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) - -// For more information, see http://www.boost.org or http://lambda.cs.utu.fi - -// Revision History -// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG) -// 10 02 01 Fixed "null_type" constructors. -// Implemented comparison operators globally. -// Hide element_type_ref and element_type_const_ref. -// (DG). -// 09 02 01 Extended to tuples of length 10. Changed comparison for -// operator<() -// to the same used by std::pair<>, added cnull_type() (GP) -// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG) - -// ----------------------------------------------------------------- - -#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP -#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP - -#include "boost/type_traits.hpp" -#include "boost/utility/swap.hpp" -#include - -#if defined BOOST_MSVC -#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored -#pragma warning(disable:4181) // qualifier applied to reference type ignored -#pragma warning(disable:4227) // qualifier applied to reference type ignored -#endif - -namespace boost { -namespace tuples { - - // null_type denotes the end of a list built with "cons" - struct null_type - { - null_type() {} - null_type(const null_type&, const null_type&) {} - }; - - // a helper function to provide a const null_type type temporary - inline const null_type cnull_type() { return null_type(); } - -// forward declaration of tuple - template< - typename T1 = null_type, - typename T2 = null_type, - typename T3 = null_type, - typename T4 = null_type, - typename T5 = null_type, - typename T6 = null_type, - typename T7 = null_type, - typename T8 = null_type, - typename T9 = null_type, - typename T10 = null_type - > - class tuple; - -// forward declaration of cons - template - struct cons; - - namespace detail { - - // Takes a pointer and routes all assignments to whatever it points to - template - struct assign_to_pointee - { - public: - explicit assign_to_pointee(T* p) : ptr(p) {} - - template - assign_to_pointee& operator=(const Other& other) - { - *ptr = other; - return *this; - } - - private: - T* ptr; - }; - - // Swallows any assignment - struct swallow_assign - { - template - swallow_assign const& operator=(const T&) const - { - return *this; - } - }; - - template struct add_const_reference : add_reference::type> {}; - - template - struct init_tail - { - // Each of vc6 and vc7 seem to require a different formulation - // of this return type - template -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - static typename add_reference::type>::type -#else - static typename add_const_reference::type -#endif - execute( cons const& u, long ) - { - return u.get_tail(); - } - }; - - template <> - struct init_tail - { - template - static null_type execute( cons const& u, long ) - { - return null_type(); - } - - template - static null_type execute(U const&, ...) - { - return null_type(); - } - private: - template - void execute( cons const&, int); - }; - - template - Other const& - init_head( Other const& u, ... ) - { - return u; - } - - template - typename add_reference::type>::type - init_head( cons const& u, int ) - { - return u.get_head(); - } - - inline char**** init_head(null_type const&, int); - - } // end of namespace detail - - // cons builds a heterogenous list of types - template - struct cons - { - typedef cons self_type; - typedef Head head_type; - typedef Tail tail_type; - - private: - typedef typename boost::add_reference::type head_ref; - typedef typename boost::add_reference::type tail_ref; - typedef typename detail::add_const_reference::type head_cref; - typedef typename detail::add_const_reference::type tail_cref; - public: - head_type head; - tail_type tail; - - head_ref get_head() { return head; } - tail_ref get_tail() { return tail; } - - head_cref get_head() const { return head; } - tail_cref get_tail() const { return tail; } - - cons() : head(), tail() {} - -#if defined BOOST_MSVC - template - cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf. - const Tail& t) : head(h), tail(t.head, t.tail) - { - } - - cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf. - const null_type& t) : head(h), tail(t) - { - } - -#else - template - explicit cons(head_cref h, const T& t) : - head(h), tail(t.head, t.tail) - { - } - - explicit cons(head_cref h = head_type(), - tail_cref t = tail_type()) : - head(h), tail(t) - { - } -#endif - - template - cons( const U& u ) - : head(detail::init_head(u, 0)) - , tail(detail::init_tail::execute(u, 0L)) - { - } - - template - cons& operator=(const Other& other) - { - head = other.head; - tail = other.tail; - return *this; - } - }; - - namespace detail { - - // Determines if the parameter is null_type - template struct is_null_type { enum { RET = 0 }; }; - template<> struct is_null_type { enum { RET = 1 }; }; - - /* Build a cons structure from the given Head and Tail. If both are null_type, - return null_type. */ - template - struct build_cons - { - private: - enum { tail_is_null_type = is_null_type::RET }; - public: - typedef cons RET; - }; - - template<> - struct build_cons - { - typedef null_type RET; - }; - - // Map the N elements of a tuple into a cons list - template< - typename T1, - typename T2 = null_type, - typename T3 = null_type, - typename T4 = null_type, - typename T5 = null_type, - typename T6 = null_type, - typename T7 = null_type, - typename T8 = null_type, - typename T9 = null_type, - typename T10 = null_type - > - struct map_tuple_to_cons - { - typedef typename detail::build_cons::RET cons10; - typedef typename detail::build_cons::RET cons9; - typedef typename detail::build_cons::RET cons8; - typedef typename detail::build_cons::RET cons7; - typedef typename detail::build_cons::RET cons6; - typedef typename detail::build_cons::RET cons5; - typedef typename detail::build_cons::RET cons4; - typedef typename detail::build_cons::RET cons3; - typedef typename detail::build_cons::RET cons2; - typedef typename detail::build_cons::RET cons1; - }; - - // Workaround the lack of partial specialization in some compilers - template - struct _element_type - { - template - struct inner - { - private: - typedef typename Tuple::tail_type tail_type; - typedef _element_type next_elt_type; - - public: - typedef typename _element_type::template inner::RET RET; - }; - }; - - template<> - struct _element_type<0> - { - template - struct inner - { - typedef typename Tuple::head_type RET; - }; - }; - - } // namespace detail - - - // Return the Nth type of the given Tuple - template - struct element - { - private: - typedef detail::_element_type nth_type; - - public: - typedef typename nth_type::template inner::RET RET; - typedef RET type; - }; - - namespace detail { - -#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300) - // special workaround for vc7: - - template - struct reference_adder - { - template - struct rebind - { - typedef T& type; - }; - }; - - template <> - struct reference_adder - { - template - struct rebind - { - typedef T type; - }; - }; - - - // Return a reference to the Nth type of the given Tuple - template - struct element_ref - { - private: - typedef typename element::RET elt_type; - enum { is_ref = is_reference::value }; - - public: - typedef reference_adder::rebind::type RET; - typedef RET type; - }; - - // Return a const reference to the Nth type of the given Tuple - template - struct element_const_ref - { - private: - typedef typename element::RET elt_type; - enum { is_ref = is_reference::value }; - - public: - typedef reference_adder::rebind::type RET; - typedef RET type; - }; - -#else // vc7 - - // Return a reference to the Nth type of the given Tuple - template - struct element_ref - { - private: - typedef typename element::RET elt_type; - - public: - typedef typename add_reference::type RET; - typedef RET type; - }; - - // Return a const reference to the Nth type of the given Tuple - template - struct element_const_ref - { - private: - typedef typename element::RET elt_type; - - public: - typedef typename add_reference::type RET; - typedef RET type; - }; -#endif // vc7 - - } // namespace detail - - // Get length of this tuple - template - struct length - { - BOOST_STATIC_CONSTANT(int, value = 1 + length::value); - }; - - template<> struct length > { - BOOST_STATIC_CONSTANT(int, value = 0); - }; - - template<> - struct length - { - BOOST_STATIC_CONSTANT(int, value = 0); - }; - - namespace detail { - - // Reference the Nth element in a tuple and retrieve it with "get" - template - struct get_class - { - template - static inline - typename detail::element_ref >::RET - get(cons& t) - { - return get_class::get(t.tail); - } - - template - static inline - typename detail::element_const_ref >::RET - get(const cons& t) - { - return get_class::get(t.tail); - } - }; - - template<> - struct get_class<0> - { - template - static inline - typename add_reference::type - get(cons& t) - { - return t.head; - } - - template - static inline - typename add_reference::type - get(const cons& t) - { - return t.head; - } - }; - - } // namespace detail - - // tuple class - template< - typename T1, - typename T2, - typename T3, - typename T4, - typename T5, - typename T6, - typename T7, - typename T8, - typename T9, - typename T10 - > - class tuple : - public detail::map_tuple_to_cons::cons1 - { - private: - typedef detail::map_tuple_to_cons mapped_tuple; - typedef typename mapped_tuple::cons10 cons10; - typedef typename mapped_tuple::cons9 cons9; - typedef typename mapped_tuple::cons8 cons8; - typedef typename mapped_tuple::cons7 cons7; - typedef typename mapped_tuple::cons6 cons6; - typedef typename mapped_tuple::cons5 cons5; - typedef typename mapped_tuple::cons4 cons4; - typedef typename mapped_tuple::cons3 cons3; - typedef typename mapped_tuple::cons2 cons2; - typedef typename mapped_tuple::cons1 cons1; - - typedef typename detail::add_const_reference::type t1_cref; - typedef typename detail::add_const_reference::type t2_cref; - typedef typename detail::add_const_reference::type t3_cref; - typedef typename detail::add_const_reference::type t4_cref; - typedef typename detail::add_const_reference::type t5_cref; - typedef typename detail::add_const_reference::type t6_cref; - typedef typename detail::add_const_reference::type t7_cref; - typedef typename detail::add_const_reference::type t8_cref; - typedef typename detail::add_const_reference::type t9_cref; - typedef typename detail::add_const_reference::type t10_cref; - public: - typedef cons1 inherited; - typedef tuple self_type; - - tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10())))))))))) - {} - - tuple( - t1_cref t1, - t2_cref t2, - t3_cref t3 = T3(), - t4_cref t4 = T4(), - t5_cref t5 = T5(), - t6_cref t6 = T6(), - t7_cref t7 = T7(), - t8_cref t8 = T8(), - t9_cref t9 = T9(), - t10_cref t10 = T10() - ) : - cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10)))))))))) - { - } - - explicit tuple(t1_cref t1) - : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10())))))))))) - {} - - template - tuple(const cons& other) : - cons1(other.head, other.tail) - { - } - - template - self_type& operator=(const std::pair& other) - { - this->head = other.first; - this->tail.head = other.second; - return *this; - } - - template - self_type& operator=(const cons& other) - { - this->head = other.head; - this->tail = other.tail; - - return *this; - } - }; - - namespace detail { - - template struct workaround_holder {}; - - } // namespace detail - - template - typename detail::element_ref >::RET - get(cons& t, detail::workaround_holder* = 0) - { - return detail::get_class::get(t); - } - - template - typename detail::element_const_ref >::RET - get(const cons& t, detail::workaround_holder* = 0) - { - return detail::get_class::get(t); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1) - { - return tuple(t1); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2) - { - return tuple(t1, t2); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3) - { - return tuple(t1, t2, t3); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) - { - return tuple(t1, t2, t3, t4); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) - { - return tuple(t1, t2, t3, t4, t5); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) - { - return tuple(t1, t2, t3, t4, t5, t6); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) - { - return tuple(t1, t2, t3, t4, t5, t6, t7); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) - { - return tuple(t1, t2, t3, t4, t5, t6, t7, t8); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) - { - return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) - { - return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); - } - - // Tie variables into a tuple - template - inline - tuple > - tie(T1& t1) - { - return make_tuple(detail::assign_to_pointee(&t1)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee > - tie(T1& t1, T2& t2) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4), - detail::assign_to_pointee(&t5)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4), - detail::assign_to_pointee(&t5), - detail::assign_to_pointee(&t6)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4), - detail::assign_to_pointee(&t5), - detail::assign_to_pointee(&t6), - detail::assign_to_pointee(&t7)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4), - detail::assign_to_pointee(&t5), - detail::assign_to_pointee(&t6), - detail::assign_to_pointee(&t7), - detail::assign_to_pointee(&t8)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4), - detail::assign_to_pointee(&t5), - detail::assign_to_pointee(&t6), - detail::assign_to_pointee(&t7), - detail::assign_to_pointee(&t8), - detail::assign_to_pointee(&t9)); - } - // Tie variables into a tuple - template - inline - tuple, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee, - detail::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10) - { - return make_tuple(detail::assign_to_pointee(&t1), - detail::assign_to_pointee(&t2), - detail::assign_to_pointee(&t3), - detail::assign_to_pointee(&t4), - detail::assign_to_pointee(&t5), - detail::assign_to_pointee(&t6), - detail::assign_to_pointee(&t7), - detail::assign_to_pointee(&t8), - detail::assign_to_pointee(&t9), - detail::assign_to_pointee(&t10)); - } - // "ignore" allows tuple positions to be ignored when using "tie". - -detail::swallow_assign const ignore = detail::swallow_assign(); - -template -void swap(tuple& lhs, - tuple& rhs); -inline void swap(null_type&, null_type&) {} -template -inline void swap(cons& lhs, cons& rhs) { - ::boost::swap(lhs.head, rhs.head); -} -template -inline void swap(cons& lhs, cons& rhs) { - ::boost::swap(lhs.head, rhs.head); - ::boost::tuples::swap(lhs.tail, rhs.tail); -} -template -inline void swap(tuple& lhs, - tuple& rhs) { - typedef tuple tuple_type; - typedef typename tuple_type::inherited base; - ::boost::tuples::swap(static_cast(lhs), static_cast(rhs)); -} - -} // namespace tuples -} // namespace boost -#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP diff --git a/src/thirdparty/boost_lib/boost/tuple/tuple.hpp b/src/thirdparty/boost_lib/boost/tuple/tuple.hpp index 7703597e1..433d4b316 100644 --- a/src/thirdparty/boost_lib/boost/tuple/tuple.hpp +++ b/src/thirdparty/boost_lib/boost/tuple/tuple.hpp @@ -23,16 +23,10 @@ namespace boost { namespace python { class tuple; }} #include "boost/config.hpp" #include "boost/static_assert.hpp" -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -// The MSVC version -#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp" - -#else // other compilers #include "boost/ref.hpp" #include "boost/tuple/detail/tuple_basic.hpp" -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { @@ -41,7 +35,7 @@ using tuples::make_tuple; using tuples::tie; #if !defined(BOOST_NO_USING_TEMPLATE) using tuples::get; -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else // // The "using tuples::get" statement causes the // Borland compiler to ICE, use forwarding @@ -64,24 +58,7 @@ inline typename tuples::access_traits< get(const tuples::cons& c) { return tuples::get(c); } -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -// -// MSVC, using declarations don't mix with templates well, -// so use forwarding functions instead: -// -template -typename tuples::detail::element_ref >::RET -get(tuples::cons& t, tuples::detail::workaround_holder* = 0) -{ - return tuples::detail::get_class::get(t); -} -template -typename tuples::detail::element_const_ref >::RET -get(const tuples::cons& t, tuples::detail::workaround_holder* = 0) -{ - return tuples::detail::get_class::get(t); -} #endif // BOOST_NO_USING_TEMPLATE } // end namespace boost diff --git a/src/thirdparty/boost_lib/boost/tuple/tuple_io.hpp b/src/thirdparty/boost_lib/boost/tuple/tuple_io.hpp index c549716eb..99cf36cb0 100644 --- a/src/thirdparty/boost_lib/boost/tuple/tuple_io.hpp +++ b/src/thirdparty/boost_lib/boost/tuple/tuple_io.hpp @@ -13,21 +13,8 @@ #ifndef BOOST_TUPLE_IO_HPP #define BOOST_TUPLE_IO_HPP - -// add to boost/config.hpp -// for now -# if defined __GNUC__ -# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) -#define BOOST_NO_TEMPLATED_STREAMS -#endif -#endif // __GNUC__ - -#if defined BOOST_NO_TEMPLATED_STREAMS -#include -#else #include #include -#endif #include @@ -76,25 +63,6 @@ class format_info { public: -#if defined (BOOST_NO_TEMPLATED_STREAMS) - static char get_manipulator(std::ios& i, manipulator_type m) { - char c = static_cast(i.iword(get_stream_index(m))); - - // parentheses and space are the default manipulators - if (!c) { - switch(m) { - case detail::format_info::open : c = '('; break; - case detail::format_info::close : c = ')'; break; - case detail::format_info::delimiter : c = ' '; break; - } - } - return c; - } - - static void set_manipulator(std::ios& i, manipulator_type m, char c) { - i.iword(get_stream_index(m)) = static_cast(c); - } -#else template static CharType get_manipulator(std::basic_ios& i, manipulator_type m) { @@ -124,7 +92,6 @@ class format_info { // convertible long. i.iword(get_stream_index(m)) = static_cast(c); } -#endif // BOOST_NO_TEMPLATED_STREAMS }; } // end of namespace detail @@ -138,39 +105,12 @@ class tuple_manipulator { const char c = 0) : mt(m), f_c(c) {} -#if defined (BOOST_NO_TEMPLATED_STREAMS) - void set(std::ios &io) const { - detail::format_info::set_manipulator(io, mt, f_c); - } -#else -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - template - void set(std::basic_ios &io) const { - detail::format_info::set_manipulator(io, mt, f_c); - } -#else template void set(std::basic_ios &io) const { detail::format_info::set_manipulator(io, mt, f_c); } -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#endif // BOOST_NO_TEMPLATED_STREAMS }; -#if defined (BOOST_NO_TEMPLATED_STREAMS) -inline std::ostream& -operator<<(std::ostream& o, const tuple_manipulator& m) { - m.set(o); - return o; -} - -inline std::istream& -operator>>(std::istream& i, const tuple_manipulator& m) { - m.set(i); - return i; -} - -#else template inline std::basic_ostream& @@ -186,7 +126,6 @@ operator>>(std::basic_istream& i, const tuple_manipulator inline tuple_manipulator set_open(const CharType c) { @@ -217,62 +156,12 @@ namespace detail { // Note: The order of the print functions is critical // to let a conforming compiler find and select the correct one. -#if defined (BOOST_NO_TEMPLATED_STREAMS) -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -template -inline std::ostream& print(std::ostream& o, const cons& t) { - return o << t.head; -} -#endif // BOOST_NO_TEMPLATED_STREAMS - -inline std::ostream& print(std::ostream& o, const null_type&) { return o; } - -template -inline std::ostream& -print(std::ostream& o, const cons& t) { - - const char d = format_info::get_manipulator(o, format_info::delimiter); - - o << t.head; - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuples::length::value == 0) - return o; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - o << d; - - return print(o, t.tail ); - -} - -template -inline bool handle_width(std::ostream& o, const T& t) { - std::streamsize width = o.width(); - if(width == 0) return false; - - std::ostringstream ss; - - ss.copyfmt(o); - ss.tie(0); - ss.width(0); - - ss << t; - o << ss.str(); - - return true; -} - - -#else - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template inline std::basic_ostream& print(std::basic_ostream& o, const cons& t) { return o << t.head; } -#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template @@ -289,10 +178,6 @@ print(std::basic_ostream& o, const cons& t) { o << t.head; -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuples::length::value == 0) - return o; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION o << d; return print(o, t.tail); @@ -315,47 +200,9 @@ inline bool handle_width(std::basic_ostream& o, const T& t) { return true; } -#endif // BOOST_NO_TEMPLATED_STREAMS } // namespace detail -#if defined (BOOST_NO_TEMPLATED_STREAMS) - -inline std::ostream& operator<<(std::ostream& o, const null_type& t) { - if (!o.good() ) return o; - if (detail::handle_width(o, t)) return o; - - const char l = - detail::format_info::get_manipulator(o, detail::format_info::open); - const char r = - detail::format_info::get_manipulator(o, detail::format_info::close); - - o << l; - o << r; - - return o; -} - -template -inline std::ostream& operator<<(std::ostream& o, const cons& t) { - if (!o.good() ) return o; - if (detail::handle_width(o, t)) return o; - - const char l = - detail::format_info::get_manipulator(o, detail::format_info::open); - const char r = - detail::format_info::get_manipulator(o, detail::format_info::close); - - o << l; - - detail::print(o, t); - - o << r; - - return o; -} - -#else template inline std::basic_ostream& @@ -395,7 +242,6 @@ operator<<(std::basic_ostream& o, return o; } -#endif // BOOST_NO_TEMPLATED_STREAMS // ------------------------------------------------------------- @@ -403,99 +249,6 @@ operator<<(std::basic_ostream& o, namespace detail { -#if defined (BOOST_NO_TEMPLATED_STREAMS) - -inline std::istream& -extract_and_check_delimiter( - std::istream& is, format_info::manipulator_type del) -{ - const char d = format_info::get_manipulator(is, del); - -#if defined (BOOST_NO_STD_LOCALE) - const bool is_delimiter = !isspace(d); -#else - const bool is_delimiter = (!std::isspace(d, is.getloc()) ); -#endif - - char c; - if (is_delimiter) { - is >> c; - if (is.good() && c!=d) { - is.setstate(std::ios::failbit); - } - } else { - is >> std::ws; - } - return is; -} - - -// Note: The order of the read functions is critical to let a -// (conforming?) compiler find and select the correct one. - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -template -inline std::istream & -read (std::istream &is, cons& t1) { - - if (!is.good()) return is; - - return is >> t1.head ; -} -#else -inline std::istream& read(std::istream& i, const null_type&) { return i; } -#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -template -inline std::istream& -read(std::istream &is, cons& t1) { - - if (!is.good()) return is; - - is >> t1.head; - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuples::length::value == 0) - return is; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - extract_and_check_delimiter(is, format_info::delimiter); - - return read(is, t1.tail); -} - -} // end namespace detail - -inline std::istream& -operator>>(std::istream &is, null_type&) { - - if (!is.good() ) return is; - - detail::extract_and_check_delimiter(is, detail::format_info::open); - detail::extract_and_check_delimiter(is, detail::format_info::close); - - return is; -} - - -template -inline std::istream& -operator>>(std::istream& is, cons& t1) { - - if (!is.good() ) return is; - - detail::extract_and_check_delimiter(is, detail::format_info::open); - - detail::read(is, t1); - - detail::extract_and_check_delimiter(is, detail::format_info::close); - - return is; -} - - - -#else template inline std::basic_istream& @@ -526,7 +279,6 @@ extract_and_check_delimiter( } -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template inline std::basic_istream & read (std::basic_istream &is, cons& t1) { @@ -535,12 +287,6 @@ read (std::basic_istream &is, cons& t1) { return is >> t1.head; } -#else -template -inline std::basic_istream& -read(std::basic_istream& i, const null_type&) { return i; } - -#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template inline std::basic_istream& @@ -550,10 +296,6 @@ read(std::basic_istream &is, cons& t1) { is >> t1.head; -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuples::length::value == 0) - return is; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION extract_and_check_delimiter(is, format_info::delimiter); @@ -590,7 +332,6 @@ operator>>(std::basic_istream& is, cons& t1) { return is; } -#endif // BOOST_NO_TEMPLATED_STREAMS } // end of namespace tuples } // end of namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/add_const.hpp b/src/thirdparty/boost_lib/boost/type_traits/add_const.hpp index 29f0bd95b..0a27f8a97 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/add_const.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/add_const.hpp @@ -36,9 +36,7 @@ BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const) # pragma warning(pop) #endif -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&) -#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/add_cv.hpp b/src/thirdparty/boost_lib/boost/type_traits/add_cv.hpp index bfde76a62..66625c66c 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/add_cv.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/add_cv.hpp @@ -37,9 +37,7 @@ BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_cv,T,T const volatile) # pragma warning(pop) #endif -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&) -#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/add_reference.hpp b/src/thirdparty/boost_lib/boost/type_traits/add_reference.hpp index f926a53b7..5e3efca69 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/add_reference.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/add_reference.hpp @@ -20,37 +20,6 @@ namespace boost { namespace detail { -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC6_MEMBER_TEMPLATES) - -template -struct reference_adder -{ - template struct result_ - { - typedef T& type; - }; -}; - -template <> -struct reference_adder -{ - template struct result_ - { - typedef T type; - }; -}; - -template -struct add_reference_impl -{ - typedef typename reference_adder< - ::boost::is_reference::value - >::template result_ result; - - typedef typename result::type type; -}; - -#else // // We can't filter out rvalue_references at the same level as // references or we get ambiguities from msvc: @@ -76,11 +45,7 @@ struct add_reference_impl typedef typename add_reference_rvalue_layer::type type; }; -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) -#endif - -#endif // these full specialisations are always required: BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void) diff --git a/src/thirdparty/boost_lib/boost/type_traits/add_rvalue_reference.hpp b/src/thirdparty/boost_lib/boost/type_traits/add_rvalue_reference.hpp index 92c2c3817..242716f09 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/add_rvalue_reference.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/add_rvalue_reference.hpp @@ -39,7 +39,7 @@ namespace type_traits_detail { struct add_rvalue_reference_helper { typedef T type; }; -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) template struct add_rvalue_reference_helper { diff --git a/src/thirdparty/boost_lib/boost/type_traits/add_volatile.hpp b/src/thirdparty/boost_lib/boost/type_traits/add_volatile.hpp index 491f1c2dd..86b529798 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/add_volatile.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/add_volatile.hpp @@ -36,9 +36,7 @@ BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile) # pragma warning(pop) #endif -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&) -#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/alignment_of.hpp b/src/thirdparty/boost_lib/boost/type_traits/alignment_of.hpp index e1735dcc6..31a5f3839 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/alignment_of.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/alignment_of.hpp @@ -90,13 +90,11 @@ BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl // references have to be treated specially, assume // that a reference is just a special pointer: -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct alignment_of : public alignment_of { }; -#endif #ifdef __BORLANDC__ // long double gives an incorrect value of 10 (!) // unless we do this... diff --git a/src/thirdparty/boost_lib/boost/type_traits/broken_compiler_spec.hpp b/src/thirdparty/boost_lib/boost/type_traits/broken_compiler_spec.hpp index fb51769d9..3a1327359 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/broken_compiler_spec.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/broken_compiler_spec.hpp @@ -9,109 +9,6 @@ #ifndef BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED #define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED -#include -#include +#include -// these are needed regardless of BOOST_TT_NO_BROKEN_COMPILER_SPEC -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -namespace boost { namespace detail { -template< typename T > struct remove_const_impl { typedef T type; }; -template< typename T > struct remove_volatile_impl { typedef T type; }; -template< typename T > struct remove_pointer_impl { typedef T type; }; -template< typename T > struct remove_reference_impl { typedef T type; }; -typedef int invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces; -}} #endif - -// agurt, 27/jun/03: disable the workaround if user defined -// BOOST_TT_NO_BROKEN_COMPILER_SPEC -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ - || defined(BOOST_TT_NO_BROKEN_COMPILER_SPEC) - -# define BOOST_TT_BROKEN_COMPILER_SPEC(T) /**/ - -#else - -// same as BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 macro, except that it -// never gets #undef-ined -# define BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(trait,spec,result) \ -template<> struct trait##_impl \ -{ \ - typedef result type; \ -}; \ -/**/ - -# define BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const,T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const volatile,T volatile) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T volatile,T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T const volatile,T const) \ - /**/ - -# define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*,T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const,T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*volatile,T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const volatile,T) \ - BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_reference,T&,T) \ - /**/ - -# define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \ - BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \ - BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const) \ - BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T volatile) \ - BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const volatile) \ - /**/ - -# define BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \ - BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \ - BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \ - /**/ - -# define BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T*) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const*) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T volatile*) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const volatile*) \ - /**/ - -# define BOOST_TT_BROKEN_COMPILER_SPEC(T) \ - namespace boost { namespace detail { \ - typedef invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces \ - please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces; \ - BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T*) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const*) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T volatile*) \ - BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const volatile*) \ - }} \ - /**/ - -# include - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -BOOST_TT_BROKEN_COMPILER_SPEC(bool) -BOOST_TT_BROKEN_COMPILER_SPEC(char) -#ifndef BOOST_NO_INTRINSIC_WCHAR_T -BOOST_TT_BROKEN_COMPILER_SPEC(wchar_t) -#endif -BOOST_TT_BROKEN_COMPILER_SPEC(signed char) -BOOST_TT_BROKEN_COMPILER_SPEC(unsigned char) -BOOST_TT_BROKEN_COMPILER_SPEC(signed short) -BOOST_TT_BROKEN_COMPILER_SPEC(unsigned short) -BOOST_TT_BROKEN_COMPILER_SPEC(signed int) -BOOST_TT_BROKEN_COMPILER_SPEC(unsigned int) -BOOST_TT_BROKEN_COMPILER_SPEC(signed long) -BOOST_TT_BROKEN_COMPILER_SPEC(unsigned long) -BOOST_TT_BROKEN_COMPILER_SPEC(float) -BOOST_TT_BROKEN_COMPILER_SPEC(double) -//BOOST_TT_BROKEN_COMPILER_SPEC(long double) - -// for backward compatibility -#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \ - BOOST_TT_BROKEN_COMPILER_SPEC(T) \ -/**/ - -#endif // BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/common_type.hpp b/src/thirdparty/boost_lib/boost/type_traits/common_type.hpp index f05777056..b52ff167e 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/common_type.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/common_type.hpp @@ -120,7 +120,7 @@ namespace type_traits_detail { typedef BOOST_TYPEOF_TPL(declval_b() ? declval_T() : declval_U()) type; #endif -#if defined(__GNUC__) && __GNUC__ == 3 && (__GNUC_MINOR__ == 2 || __GNUC_MINOR__ == 3) +#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ == 3 public: void public_dummy_function_just_to_silence_warning(); #endif diff --git a/src/thirdparty/boost_lib/boost/type_traits/config.hpp b/src/thirdparty/boost_lib/boost/type_traits/config.hpp index 793445429..2e25ad01f 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/config.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/config.hpp @@ -27,8 +27,6 @@ #endif # if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \ - || BOOST_WORKAROUND(BOOST_MSVC, <= 1301) \ - || !defined(__EDG_VERSION__) && BOOST_WORKAROUND(__GNUC__, < 3) \ || BOOST_WORKAROUND(__IBMCPP__, < 600 ) \ || BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \ || defined(__ghs) \ @@ -45,14 +43,6 @@ # define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1 #endif -// -// Define BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING -// when we can't test for function types with elipsis: -// -#if BOOST_WORKAROUND(__GNUC__, < 3) -# define BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING -#endif - // // define BOOST_TT_TEST_MS_FUNC_SIGS // when we want to test __stdcall etc function types with is_function etc @@ -71,6 +61,12 @@ # define BOOST_TT_NO_CV_FUNC_TEST #endif +// +// Macros that have been deprecated, defined here for backwards compatibility: +// +#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x) +#define BOOST_TT_BROKEN_COMPILER_SPEC(x) + #endif // BOOST_TT_CONFIG_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_def.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_def.hpp index e3c7774e3..69e4f1ca6 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_def.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_def.hpp @@ -8,8 +8,8 @@ // http://www.boost.org/LICENSE_1_0.txt) // $Source$ -// $Date: 2011-10-09 15:28:33 -0700 (Sun, 09 Oct 2011) $ -// $Revision: 74865 $ +// $Date$ +// $Revision$ #include #include @@ -45,14 +45,6 @@ enum { value = type::value }; \ /**/ # define BOOST_TT_AUX_BOOL_C_BASE(C) - -#elif defined(BOOST_MSVC) && BOOST_MSVC < 1300 - -# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ - typedef ::boost::integral_constant base_; \ - using base_::value; \ - /**/ - #endif #ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_undef.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_undef.hpp index 008febe79..4ac61ef2e 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_undef.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/bool_trait_undef.hpp @@ -8,8 +8,8 @@ // http://www.boost.org/LICENSE_1_0.txt) // $Source$ -// $Date: 2011-10-09 15:28:33 -0700 (Sun, 09 Oct 2011) $ -// $Revision: 74865 $ +// $Date$ +// $Revision$ #undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL #undef BOOST_TT_AUX_BOOL_C_BASE diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/cv_traits_impl.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/cv_traits_impl.hpp index ed20c9d41..8e995bb06 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/cv_traits_impl.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/cv_traits_impl.hpp @@ -11,24 +11,93 @@ #ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED #define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED +#include #include #include -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // implementation helper: -#if !(BOOST_WORKAROUND(__GNUC__,== 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 2)) namespace boost { namespace detail { -#else -#include -namespace boost { -namespace type_traits { -namespace gcc8503 { -#endif +#if BOOST_WORKAROUND(BOOST_MSVC, == 1700) +#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[N]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[N]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[N]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[N]; + }; + +#else +#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X * template struct cv_traits_imp {}; template @@ -38,9 +107,10 @@ struct cv_traits_imp BOOST_STATIC_CONSTANT(bool, is_volatile = false); typedef T unqualified_type; }; +#endif template -struct cv_traits_imp +struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = true); BOOST_STATIC_CONSTANT(bool, is_volatile = false); @@ -48,7 +118,7 @@ struct cv_traits_imp }; template -struct cv_traits_imp +struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = false); BOOST_STATIC_CONSTANT(bool, is_volatile = true); @@ -56,42 +126,15 @@ struct cv_traits_imp }; template -struct cv_traits_imp +struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = true); BOOST_STATIC_CONSTANT(bool, is_volatile = true); typedef T unqualified_type; }; -#if BOOST_WORKAROUND(__GNUC__,== 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 2) -// We have to exclude function pointers -// (see http://gcc.gnu.org/bugzilla/show_bug.cgi?8503) -yes_type mini_funcptr_tester(...); -no_type mini_funcptr_tester(const volatile void*); - -} // namespace gcc8503 -} // namespace type_traits - -namespace detail { - -// Use the implementation above for non function pointers -template -struct cv_traits_imp : public ::boost::type_traits::gcc8503::cv_traits_imp { }; - -// Functions are never cv-qualified -template struct cv_traits_imp -{ - BOOST_STATIC_CONSTANT(bool, is_const = false); - BOOST_STATIC_CONSTANT(bool, is_volatile = false); - typedef T unqualified_type; -}; - -#endif - } // namespace detail } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/has_binary_operator.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/has_binary_operator.hpp index 1fd26efb7..d82a5cefd 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/has_binary_operator.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/has_binary_operator.hpp @@ -36,7 +36,7 @@ // warning C4804: '<' : unsafe use of type 'bool' in operation // warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation // cannot find another implementation -> declared as system header to suppress these warnings. -#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3)) +#if defined(__GNUC__) # pragma GCC system_header #elif defined(BOOST_MSVC) # pragma warning ( push ) @@ -152,10 +152,10 @@ no_operator operator,(no_operator, has_operator); template < typename Lhs, typename Rhs > struct operator_exists { - static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists - static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise + static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists + static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise - BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make() BOOST_TT_TRAIT_OP make()),make())))==sizeof(::boost::type_traits::yes_type))); + BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make() BOOST_TT_TRAIT_OP make()),make())))==sizeof(::boost::type_traits::yes_type))); }; diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/has_postfix_operator.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/has_postfix_operator.hpp index 5c52b07d2..e9048e121 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/has_postfix_operator.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/has_postfix_operator.hpp @@ -22,7 +22,7 @@ #include // avoid warnings -#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3)) +#if defined(__GNUC__) # pragma GCC system_header #elif defined(BOOST_MSVC) # pragma warning ( push ) @@ -138,10 +138,10 @@ no_operator operator,(no_operator, has_operator); template < typename Lhs > struct operator_exists { - static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists - static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise + static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists + static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise - BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make() BOOST_TT_TRAIT_OP),make())))==sizeof(::boost::type_traits::yes_type))); + BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make() BOOST_TT_TRAIT_OP),make())))==sizeof(::boost::type_traits::yes_type))); }; diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/has_prefix_operator.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/has_prefix_operator.hpp index ac30e4dfa..e1cf8d054 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/has_prefix_operator.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/has_prefix_operator.hpp @@ -30,7 +30,7 @@ // warning C4146: unary minus operator applied to unsigned type, result still unsigned // warning C4804: '-' : unsafe use of type 'bool' in operation // cannot find another implementation -> declared as system header to suppress these warnings. -#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3)) +#if defined(__GNUC__) # pragma GCC system_header #elif defined(BOOST_MSVC) # pragma warning ( push ) @@ -146,10 +146,10 @@ no_operator operator,(no_operator, has_operator); template < typename Rhs > struct operator_exists { - static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists - static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise + static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists + static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise - BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make()),make())))==sizeof(::boost::type_traits::yes_type))); + BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((BOOST_TT_TRAIT_OP make()),make())))==sizeof(::boost::type_traits::yes_type))); }; diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_helper.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_helper.hpp index 605d0bc2e..1c3b17f6d 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_helper.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_helper.hpp @@ -37,160 +37,108 @@ struct is_function_ptr_helper template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #else #undef BOOST_STATIC_CONSTANT diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_tester.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_tester.hpp index 2ab49a39a..2eb8a6f47 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_tester.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/is_function_ptr_tester.hpp @@ -36,575 +36,367 @@ no_type BOOST_TT_DECL is_function_ptr_tester(...); template yes_type is_function_ptr_tester(R (*)()); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)()); -template -yes_type is_function_ptr_tester(R (__stdcall*)( ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)()); -template -yes_type is_function_ptr_tester(R (__fastcall*)( ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)()); -template -yes_type is_function_ptr_tester(R (__cdecl*)( ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); #endif template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); -template -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); #ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); -template -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); #endif template yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); -template -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); #endif #else @@ -636,18 +428,12 @@ yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) . @#ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); -template -yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); @#ifndef _MANAGED template yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); -template -yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); @#endif template yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); -template -yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); @#endif #undef BOOST_PP_COUNTER diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp index 4f75f14d0..bd5c591b2 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp @@ -37,10 +37,8 @@ struct is_mem_fun_pointer_impl template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -52,7 +50,6 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(boo template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -62,13 +59,10 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -80,7 +74,6 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT( template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -90,13 +83,10 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC_CONST template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -108,7 +98,6 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC_CONS template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -118,13 +107,10 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC_ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -136,7 +122,6 @@ struct is_mem_fun_pointer_impl { BOOST_STATIC template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -146,13 +131,10 @@ struct is_mem_fun_pointer_impl { BOOST_ST template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -164,7 +146,6 @@ struct is_mem_fun_pointer_impl { BOOST_S template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -174,13 +155,10 @@ struct is_mem_fun_pointer_impl { BOO template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -192,7 +170,6 @@ struct is_mem_fun_pointer_impl { BO template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -202,13 +179,10 @@ struct is_mem_fun_pointer_impl template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -220,7 +194,6 @@ struct is_mem_fun_pointer_impl template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -230,13 +203,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -248,7 +218,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -258,13 +227,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -276,7 +242,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -286,13 +251,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -304,7 +266,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -314,13 +275,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -332,7 +290,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -342,13 +299,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -360,7 +314,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -370,13 +323,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -388,7 +338,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -398,13 +347,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -416,7 +362,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -426,13 +371,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -444,7 +386,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -454,13 +395,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -472,7 +410,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -482,13 +419,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -500,7 +434,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -510,13 +443,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -528,7 +458,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -538,13 +467,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -556,7 +482,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -566,13 +491,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -584,7 +506,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -594,13 +515,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -612,7 +530,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -622,13 +539,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -640,7 +554,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -650,13 +563,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -668,7 +578,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -678,13 +587,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -696,7 +602,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -706,13 +611,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -724,7 +626,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -734,13 +635,10 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template @@ -752,7 +650,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @@ -762,7 +659,6 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#endif #else diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp index e6532d39d..334a84345 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp @@ -44,7 +44,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() volatile); template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...)); @@ -56,7 +55,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)()); @@ -70,18 +68,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() volatile) template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)()); @@ -95,17 +81,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() volatile template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) const volatile); #endif template @@ -120,17 +95,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() volatile); template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0)); @@ -144,7 +108,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...)); @@ -156,7 +119,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0)); @@ -170,18 +132,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) volati template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0)); @@ -195,17 +145,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) volat template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) const volatile); #endif template @@ -220,17 +159,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) volatile template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1)); @@ -244,7 +172,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...)); @@ -256,7 +183,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) volatil template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1)); @@ -270,18 +196,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) v template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1)); @@ -295,17 +209,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) const volatile); #endif template @@ -320,17 +223,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) vol template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2)); @@ -344,7 +236,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) volati template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...)); @@ -356,7 +247,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) vo template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2)); @@ -370,18 +260,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2)); @@ -395,17 +273,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) const volatile); #endif template @@ -420,17 +287,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3)); @@ -444,7 +300,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) v template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...)); @@ -456,7 +311,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 .. template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3)); @@ -470,18 +324,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3)); @@ -495,17 +337,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile); #endif template @@ -520,17 +351,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); @@ -544,7 +364,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...)); @@ -556,7 +375,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); @@ -570,18 +388,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); @@ -595,17 +401,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile); #endif template @@ -620,17 +415,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); @@ -644,7 +428,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); @@ -656,7 +439,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); @@ -670,18 +452,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); @@ -695,17 +465,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile); #endif template @@ -720,17 +479,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); @@ -744,7 +492,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); @@ -756,7 +503,7 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile); -#endif + #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); @@ -770,18 +517,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); @@ -795,17 +530,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile); #endif template @@ -820,17 +544,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); @@ -844,7 +557,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); @@ -856,7 +568,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); @@ -870,18 +581,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); @@ -895,17 +594,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile); #endif template @@ -920,17 +608,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); @@ -944,7 +621,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); @@ -956,7 +632,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); @@ -970,18 +645,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); @@ -995,17 +658,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile); #endif template @@ -1020,17 +672,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); @@ -1044,7 +685,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); @@ -1056,7 +696,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); @@ -1070,18 +709,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); @@ -1095,17 +722,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile); #endif template @@ -1120,17 +736,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); @@ -1144,7 +749,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); @@ -1156,7 +760,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); @@ -1170,18 +773,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); @@ -1195,17 +786,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile); #endif template @@ -1220,17 +800,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); @@ -1244,7 +813,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); @@ -1256,7 +824,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); @@ -1270,18 +837,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); @@ -1295,17 +850,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile); #endif template @@ -1320,17 +864,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); @@ -1344,7 +877,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); @@ -1356,7 +888,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); @@ -1370,18 +901,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); @@ -1395,17 +914,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile); #endif template @@ -1420,17 +928,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); @@ -1444,7 +941,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); @@ -1456,7 +952,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); @@ -1470,18 +965,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); @@ -1495,17 +978,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile); #endif template @@ -1520,17 +992,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); @@ -1544,7 +1005,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); @@ -1556,7 +1016,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); @@ -1570,18 +1029,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); @@ -1595,42 +1042,20 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const); +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile); +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); @@ -1644,7 +1069,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); @@ -1656,7 +1080,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); @@ -1670,18 +1093,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); @@ -1695,17 +1106,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile); #endif template @@ -1720,17 +1120,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); @@ -1744,7 +1133,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); @@ -1756,7 +1144,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); @@ -1770,18 +1157,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); @@ -1795,17 +1170,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile); #endif template @@ -1820,17 +1184,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); @@ -1844,7 +1197,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); @@ -1856,7 +1208,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); @@ -1870,18 +1221,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); @@ -1895,17 +1234,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile); #endif template @@ -1920,17 +1248,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); @@ -1944,7 +1261,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); @@ -1956,7 +1272,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); @@ -1970,18 +1285,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); @@ -1995,17 +1298,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile); #endif template @@ -2020,17 +1312,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); @@ -2044,7 +1325,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); @@ -2056,7 +1336,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); @@ -2070,18 +1349,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); @@ -2095,17 +1362,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile); #endif template @@ -2120,17 +1376,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); @@ -2144,7 +1389,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); @@ -2156,7 +1400,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); @@ -2170,18 +1413,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); @@ -2195,17 +1426,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile); #endif template @@ -2220,17 +1440,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); @@ -2244,7 +1453,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); @@ -2256,7 +1464,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); @@ -2270,18 +1477,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); @@ -2295,17 +1490,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile); #endif template @@ -2320,17 +1504,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); @@ -2344,7 +1517,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); @@ -2356,7 +1528,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); @@ -2370,18 +1541,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); @@ -2395,17 +1554,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile); #endif template @@ -2420,17 +1568,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); @@ -2444,7 +1581,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); @@ -2456,7 +1592,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); @@ -2470,18 +1605,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); @@ -2495,17 +1618,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile); #endif template @@ -2520,17 +1632,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile); #endif template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); @@ -2544,7 +1645,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); -#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); @@ -2556,7 +1656,6 @@ yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , template yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile); -#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); @@ -2570,18 +1669,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile); - #ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); @@ -2595,17 +1682,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile); #endif template @@ -2620,17 +1696,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile); #endif #else @@ -2692,18 +1757,6 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_EN template yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile); - @#ifndef _MANAGED template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); @@ -2717,17 +1770,6 @@ yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_E template yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile); @#endif template @@ -2742,17 +1784,6 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM template yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile); - -template -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile); @#endif #undef BOOST_PP_COUNTER diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_def.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_def.hpp index 3be4f70af..8cea9b452 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_def.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_def.hpp @@ -8,8 +8,8 @@ // http://www.boost.org/LICENSE_1_0.txt) // $Source$ -// $Date: 2011-04-25 05:26:48 -0700 (Mon, 25 Apr 2011) $ -// $Revision: 71481 $ +// $Date$ +// $Revision$ #include #include @@ -18,24 +18,16 @@ #include -#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300 -# define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant -# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/ -#else -# define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::mpl::size_t -# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ - typedef ::boost::mpl::size_t base_; \ - using base_::value; \ - /**/ -#endif +// Obsolete. Remove. +#define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant +#define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/ #define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \ template< typename T > struct trait \ - : BOOST_TT_AUX_SIZE_T_BASE(C) \ + : public ::boost::integral_constant \ { \ public:\ - BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ }; \ \ @@ -44,17 +36,16 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ #define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \ template<> struct trait \ - : BOOST_TT_AUX_SIZE_T_BASE(C) \ + : public ::boost::integral_constant \ { \ public:\ - BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ }; \ /**/ #define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \ template< param > struct trait \ - : BOOST_TT_AUX_SIZE_T_BASE(C) \ + : public ::boost::integral_constant \ { \ }; \ /**/ diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_undef.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_undef.hpp index 967fd9163..1694fac77 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_undef.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/size_t_trait_undef.hpp @@ -8,8 +8,8 @@ // http://www.boost.org/LICENSE_1_0.txt) // $Source$ -// $Date: 2004-09-02 08:41:37 -0700 (Thu, 02 Sep 2004) $ -// $Revision: 24874 $ +// $Date$ +// $Revision$ #undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1 #undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1 diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_def.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_def.hpp index 224f84887..bc54696b5 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_def.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_def.hpp @@ -8,8 +8,8 @@ // http://www.boost.org/LICENSE_1_0.txt) // $Source$ -// $Date: 2011-04-25 05:26:48 -0700 (Mon, 25 Apr 2011) $ -// $Revision: 71481 $ +// $Date$ +// $Revision$ #include #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_undef.hpp b/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_undef.hpp index c4f14ff8d..d8edf6627 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_undef.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/detail/type_trait_undef.hpp @@ -8,8 +8,8 @@ // http://www.boost.org/LICENSE_1_0.txt) // $Source$ -// $Date: 2004-09-02 08:41:37 -0700 (Thu, 02 Sep 2004) $ -// $Revision: 24874 $ +// $Date$ +// $Revision$ #undef BOOST_TT_AUX_TYPE_TRAIT_DEF1 #undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1 diff --git a/src/thirdparty/boost_lib/boost/type_traits/extent.hpp b/src/thirdparty/boost_lib/boost/type_traits/extent.hpp index 27e8a670f..c41f7f2ff 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/extent.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/extent.hpp @@ -31,7 +31,7 @@ struct extent_imp { BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template struct extent_imp { @@ -131,10 +131,6 @@ template struct extent : public ::boost::integral_constant::value> { -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - typedef ::boost::integral_constant::value> base_; - using base_::value; -#endif BOOST_MPL_AUX_LAMBDA_SUPPORT(1,extent,(T)) }; diff --git a/src/thirdparty/boost_lib/boost/type_traits/function_traits.hpp b/src/thirdparty/boost_lib/boost/type_traits/function_traits.hpp index d71534572..26d7e05c5 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/function_traits.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/function_traits.hpp @@ -15,7 +15,6 @@ namespace boost { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { template struct function_traits_helper; @@ -170,67 +169,6 @@ struct function_traits : { }; -#else - -namespace detail { - -template -struct type_of_size -{ - char elements[N]; -}; - -template -type_of_size<1> function_arity_helper(R (*f)()); - -template -type_of_size<2> function_arity_helper(R (*f)(T1)); - -template -type_of_size<3> function_arity_helper(R (*f)(T1, T2)); - -template -type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3)); - -template -type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4)); - -template -type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5)); - -template -type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6)); - -template -type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7)); - -template -type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8)); - -template -type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, - T9)); - -template -type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, - T9, T10)); -} // end namespace detail - -// Won't work with references -template -struct function_traits -{ - BOOST_STATIC_CONSTANT(unsigned, arity = (sizeof(boost::detail::function_arity_helper((Function*)0))-1)); -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } #endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/has_logical_not.hpp b/src/thirdparty/boost_lib/boost/type_traits/has_logical_not.hpp index fd99d3cbb..d36858e1e 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/has_logical_not.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/has_logical_not.hpp @@ -9,6 +9,11 @@ #ifndef BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED #define BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED +#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" +#endif + #define BOOST_TT_TRAIT_NAME has_logical_not #define BOOST_TT_TRAIT_OP ! #define BOOST_TT_FORBIDDEN_IF\ @@ -20,4 +25,8 @@ #undef BOOST_TT_TRAIT_OP #undef BOOST_TT_FORBIDDEN_IF +#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800) +#pragma GCC diagnostic pop +#endif + #endif diff --git a/src/thirdparty/boost_lib/boost/type_traits/has_new_operator.hpp b/src/thirdparty/boost_lib/boost/type_traits/has_new_operator.hpp index 2c2c32228..c615127da 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/has_new_operator.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/has_new_operator.hpp @@ -18,6 +18,16 @@ // should be the last #include #include +#if defined(new) +# if BOOST_WORKAROUND(BOOST_MSVC, >= 1310) +# define BOOST_TT_AUX_MACRO_NEW_DEFINED +# pragma push_macro("new") +# undef new +# else +# error "Sorry but you can't include this header if 'new' is defined as a macro." +# endif +#endif + namespace boost { namespace detail { template @@ -135,6 +145,10 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_new_operator,T,::boost::detail::has_new_operato } // namespace boost +#if defined(BOOST_TT_AUX_MACRO_NEW_DEFINED) +# pragma pop_macro("new") +#endif + #include #endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/integral_constant.hpp b/src/thirdparty/boost_lib/boost/type_traits/integral_constant.hpp index 4ed1bb058..c6847715e 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/integral_constant.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/integral_constant.hpp @@ -24,24 +24,10 @@ struct integral_constant : public mpl::integral_c template<> struct integral_constant : public mpl::true_ { -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -# pragma warning(push) -# pragma warning(disable:4097) - typedef mpl::true_ base_; - using base_::value; -# pragma warning(pop) -#endif typedef integral_constant type; }; template<> struct integral_constant : public mpl::false_ { -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -# pragma warning(push) -# pragma warning(disable:4097) - typedef mpl::false_ base_; - using base_::value; -# pragma warning(pop) -#endif typedef integral_constant type; }; diff --git a/src/thirdparty/boost_lib/boost/type_traits/integral_promotion.hpp b/src/thirdparty/boost_lib/boost/type_traits/integral_promotion.hpp index 2109b9c60..9c5514b11 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/integral_promotion.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/integral_promotion.hpp @@ -43,8 +43,7 @@ template<> struct need_promotion : public true_type {}; // Same set of integral types as in boost/type_traits/is_integral.hpp. // Please, keep in sync. -#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \ - || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ +#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) // TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types. BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 ) diff --git a/src/thirdparty/boost_lib/boost/type_traits/intrinsics.hpp b/src/thirdparty/boost_lib/boost/type_traits/intrinsics.hpp index 799f9b63f..4bcfd3c86 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/intrinsics.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/intrinsics.hpp @@ -109,8 +109,8 @@ // # define BOOST_ALIGNMENT_OF(T) __alignof(T) # if defined(_MSC_VER) && (_MSC_VER >= 1700) -# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || ::boost::is_pod::value) && !::boost::is_volatile::value) -# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || ::boost::is_pod::value) && ! ::boost::is_const::value && !::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || ::boost::is_pod::value) && !::boost::is_volatile::value && !::boost::is_reference::value) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || ::boost::is_pod::value) && ! ::boost::is_const::value && !::boost::is_volatile::value && !::boost::is_reference::value) # endif # define BOOST_HAS_TYPE_TRAITS_INTRINSICS diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_abstract.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_abstract.hpp index d88c14399..f1cd92c67 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_abstract.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_abstract.hpp @@ -1,7 +1,7 @@ #ifndef BOOST_TT_IS_ABSTRACT_CLASS_HPP #define BOOST_TT_IS_ABSTRACT_CLASS_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -19,7 +19,7 @@ // Compile type discovery whether given type is abstract class or not. // // Requires DR 337 to be supported by compiler -// (http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#337). +// (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#337). // // // Believed (Jan 2004) to work on: diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_array.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_array.hpp index 91c0f156d..c381ca4e7 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_array.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_array.hpp @@ -16,10 +16,6 @@ #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# include -# include -#endif #include @@ -30,7 +26,7 @@ namespace boost { #if defined( __CODEGEARC__ ) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,__is_array(T)) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false) #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true) @@ -45,45 +41,8 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const volatile[],t #endif #endif -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -namespace detail { - -using ::boost::type_traits::yes_type; -using ::boost::type_traits::no_type; -using ::boost::type_traits::wrap; - -template< typename T > T(* is_array_tester1(wrap) )(wrap); -char BOOST_TT_DECL is_array_tester1(...); - -template< typename T> no_type is_array_tester2(T(*)(wrap)); -yes_type BOOST_TT_DECL is_array_tester2(...); - -template< typename T > -struct is_array_impl -{ - BOOST_STATIC_CONSTANT(bool, value = - sizeof(::boost::detail::is_array_tester2( - ::boost::detail::is_array_tester1( - ::boost::type_traits::wrap() - ) - )) == 1 - ); -}; - -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void volatile,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const volatile,false) #endif -} // namespace detail - -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,::boost::detail::is_array_impl::value) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - } // namespace boost #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_base_and_derived.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_base_and_derived.hpp index d6a999118..632b69944 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_base_and_derived.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_base_and_derived.hpp @@ -237,11 +237,9 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF2( , (::boost::detail::is_base_and_derived_impl::value) ) -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base,Derived&,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false) -#endif #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename Base,is_base_and_derived,Base,Base,false) diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_base_of.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_base_of.hpp index 0cc7a32fc..3655b0bd2 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_base_of.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_base_of.hpp @@ -38,11 +38,9 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF2( , Derived , (::boost::detail::is_base_of_imp::value)) -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false) -#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_base_of_tr1.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_base_of_tr1.hpp index 177e62b0f..7264f159f 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_base_of_tr1.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_base_of_tr1.hpp @@ -37,11 +37,9 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF2( , Derived , (::boost::tr1::detail::is_base_of_imp::value)) -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false) -#endif } } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_class.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_class.hpp index 1a2cd2015..0675b5782 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_class.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_class.hpp @@ -93,7 +93,6 @@ struct is_class_impl template struct is_class_impl { -# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_union::value >::value, @@ -103,16 +102,6 @@ struct is_class_impl ::boost::type_traits::ice_not< ::boost::is_void::value >::value, ::boost::type_traits::ice_not< ::boost::is_function::value >::value >::value)); -# else - BOOST_STATIC_CONSTANT(bool, value = - (::boost::type_traits::ice_and< - ::boost::type_traits::ice_not< ::boost::is_union::value >::value, - ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, - ::boost::type_traits::ice_not< ::boost::is_array::value >::value, - ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, - ::boost::type_traits::ice_not< ::boost::is_void::value >::value - >::value)); -# endif }; # endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_const.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_const.hpp index 0c7da4a2f..e3e62b697 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_const.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_const.hpp @@ -24,7 +24,6 @@ #include #include -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include # ifdef __GNUC__ # include @@ -32,12 +31,6 @@ # if BOOST_WORKAROUND(BOOST_MSVC, < 1400) # include # endif -#else -# include -# include -# include -# include -#endif // should be the last #include #include @@ -48,7 +41,7 @@ namespace boost { BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T)) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else namespace detail{ // @@ -61,7 +54,7 @@ struct is_const_rvalue_filter #if BOOST_WORKAROUND(BOOST_MSVC, < 1400) BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::type*>::is_const); #else - BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::is_const); + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::is_const); #endif }; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES @@ -87,76 +80,8 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& volatile,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false) #endif -#if defined(__GNUC__) && (__GNUC__ < 3) -// special case for gcc where illegally cv-qualified reference types can be -// generated in some corner cases: -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T const,!(::boost::is_reference::value)) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T volatile const,!(::boost::is_reference::value)) -#endif - -#else - -namespace detail { - -using ::boost::type_traits::yes_type; -using ::boost::type_traits::no_type; - -yes_type is_const_tester(const volatile void*); -no_type is_const_tester(volatile void *); - -template -struct is_const_helper - : public ::boost::type_traits::false_result -{ -}; - -template <> -struct is_const_helper -{ - template struct result_ - { - static T* t; - BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(t)) - )); - }; -}; - -template <> -struct is_const_helper -{ - template struct result_ - { - static T t; - BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(&t)) - )); - }; -}; - -template -struct is_const_impl - : public is_const_helper< - is_reference::value - , is_array::value - >::template result_ -{ -}; - -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void,false) -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void volatile,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const volatile,true) #endif -} // namespace detail - -//* is a type T declared const - is_const -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_impl::value) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - } // namespace boost #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_convertible.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_convertible.hpp index 3eccadc58..a844cecb3 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_convertible.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_convertible.hpp @@ -30,7 +30,9 @@ #if defined(__MWERKS__) #include #endif - +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +# include +#endif #endif // BOOST_IS_CONVERTIBLE // should be always the last #include directive @@ -52,42 +54,43 @@ namespace boost { namespace detail { -// MS specific version: +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) -#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) + // This is a C++11 conforming version, place this first and use it wherever possible: -// This workaround is necessary to handle when From is void -// which is normally taken care of by the partial specialization -// of the is_convertible typename. -using ::boost::type_traits::yes_type; -using ::boost::type_traits::no_type; +# define BOOST_TT_CXX11_IS_CONVERTIBLE -template< typename From > -struct does_conversion_exist -{ - template< typename To > struct result_ - { - static no_type BOOST_TT_DECL _m_check(...); - static yes_type BOOST_TT_DECL _m_check(To); - static typename add_lvalue_reference::type _m_from; - enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) }; - }; -}; + template + struct or_helper + { + static const bool value = (A::value || B::value || C::value); + }; -template<> -struct does_conversion_exist -{ - template< typename To > struct result_ - { - enum { value = ::boost::is_void::value }; - }; -}; + template, boost::is_function, boost::is_array >::value> + struct is_convertible_basic_impl + { + // Nothing converts to function or array, but void converts to void: + static const bool value = is_void::value; + }; -template -struct is_convertible_basic_impl - : public does_conversion_exist::template result_ -{ -}; + template + class is_convertible_basic_impl + { + typedef char one; + typedef int two; + + template + static void test_aux(To1); + + template + static decltype(test_aux(boost::declval()), one()) test(int); + + template + static two test(...); + + public: + static const bool value = sizeof(test(0)) == 1; + }; #elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) // @@ -415,7 +418,8 @@ struct is_convertible_impl_dispatch_base typedef is_convertible_impl_select< ::boost::is_arithmetic::value, ::boost::is_arithmetic::value, -#ifndef BOOST_NO_IS_ABSTRACT +#if !defined(BOOST_NO_IS_ABSTRACT) && !defined(BOOST_TT_CXX11_IS_CONVERTIBLE) + // We need to filter out abstract types, only if we don't have a strictly conforming C++11 version: ::boost::is_abstract::value #else false @@ -462,7 +466,6 @@ struct is_convertible_impl_dispatch BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true) #endif // BOOST_NO_CV_VOID_SPECIALIZATIONS -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS @@ -473,7 +476,6 @@ BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,v BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,false) #endif -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace detail diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_empty.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_empty.hpp index 8a2c5b8bc..adb239ee2 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_empty.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_empty.hpp @@ -14,19 +14,9 @@ #include #include -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include # include # include -#else -# include -# include -# include -# include -# include -# include -# include -#endif // should be always the last #include directive #include @@ -41,7 +31,6 @@ namespace boost { namespace detail { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #ifdef BOOST_MSVC #pragma warning(push) @@ -130,82 +119,6 @@ struct is_empty_impl #endif // __BORLANDC__ -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -#ifdef BOOST_MSVC6_MEMBER_TEMPLATES - -template -struct empty_helper_t1 : public T -{ - empty_helper_t1(); - int i[256]; -}; - -struct empty_helper_t2 { int i[256]; }; - -template -struct empty_helper_base -{ - enum { value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) }; -}; - -template -struct empty_helper_nonbase -{ - enum { value = false }; -}; - -template -struct empty_helper_chooser -{ - template struct result_ - { - typedef empty_helper_nonbase type; - }; -}; - -template <> -struct empty_helper_chooser -{ - template struct result_ - { - typedef empty_helper_base type; - }; -}; - -template -struct is_empty_impl -{ - typedef ::boost::detail::empty_helper_chooser< - ::boost::type_traits::ice_and< - ::boost::type_traits::ice_not< ::boost::is_reference::value >::value, - ::boost::type_traits::ice_not< ::boost::is_convertible::value >::value, - ::boost::type_traits::ice_not< ::boost::is_pointer::value >::value, - ::boost::type_traits::ice_not< ::boost::is_member_pointer::value >::value, - ::boost::type_traits::ice_not< ::boost::is_array::value >::value, - ::boost::type_traits::ice_not< ::boost::is_void::value >::value, - ::boost::type_traits::ice_not< - ::boost::is_convertible::value - >::value - >::value > chooser; - - typedef typename chooser::template result_ result; - typedef typename result::type eh_type; - - BOOST_STATIC_CONSTANT(bool, value = - (::boost::type_traits::ice_or::value)); -}; - -#else - -template struct is_empty_impl -{ - BOOST_STATIC_CONSTANT(bool, value = BOOST_INTERNAL_IS_EMPTY(T)); -}; - -#endif // BOOST_MSVC6_MEMBER_TEMPLATES - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // these help when the compiler has no partial specialization support: BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void,false) diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_enum.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_enum.hpp index e35548c54..7929c962a 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_enum.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_enum.hpp @@ -55,13 +55,12 @@ struct is_class_or_union template struct is_class_or_union { -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way. +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way. BOOST_STATIC_CONSTANT(bool, value = false); # else template static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void)); -# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) \ - || BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE +# if BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE static ::boost::type_traits::no_type is_class_or_union_tester(...); BOOST_STATIC_CONSTANT( bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_function.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_function.hpp index cd80e740f..eeb438201 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_function.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_function.hpp @@ -15,7 +15,7 @@ #include #include -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) # include #else # include @@ -37,7 +37,7 @@ namespace boost { namespace detail { -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) template struct is_function_chooser : public ::boost::type_traits::false_result @@ -79,7 +79,6 @@ struct is_function_impl #endif }; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template struct is_function_impl : public false_type {}; @@ -88,7 +87,6 @@ template struct is_function_impl : public false_type {}; #endif -#endif #endif diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_integral.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_integral.hpp index 1ab27fd39..6bfad49d3 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_integral.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_integral.hpp @@ -46,8 +46,7 @@ BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,wchar_t,true) // Same set of integral types as in boost/type_traits/integral_promotion.hpp. // Please, keep in sync. -- Alexander Nasonov -#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \ - || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ +#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int8,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int8,true) diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_lvalue_reference.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_lvalue_reference.hpp index a6af859ab..0b0130ab2 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_lvalue_reference.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_lvalue_reference.hpp @@ -23,10 +23,6 @@ #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# include -# include -#endif // should be the last #include #include @@ -35,7 +31,7 @@ namespace boost { #if defined( __CODEGEARC__ ) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,__is_reference(T)) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T&,true) @@ -50,66 +46,8 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& volati BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& const volatile,true) #endif -#if defined(__GNUC__) && (__GNUC__ < 3) -// these allow us to work around illegally cv-qualified reference -// types. -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T const ,::boost::is_lvalue_reference::value) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T volatile ,::boost::is_lvalue_reference::value) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T const volatile ,::boost::is_lvalue_reference::value) -// However, the above specializations confuse gcc 2.96 unless we also -// supply these specializations for array types -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,T[N],false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,const T[N],false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,volatile T[N],false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,const volatile T[N],false) #endif -#else - -#ifdef BOOST_MSVC -# pragma warning(push) -# pragma warning(disable: 4181 4097) -#endif - -namespace detail { - -using ::boost::type_traits::yes_type; -using ::boost::type_traits::no_type; -using ::boost::type_traits::wrap; - -template T&(* is_lvalue_reference_helper1(wrap) )(wrap); -char is_lvalue_reference_helper1(...); - -template no_type is_lvalue_reference_helper2(T&(*)(wrap)); -yes_type is_lvalue_reference_helper2(...); - -template -struct is_lvalue_reference_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = sizeof( - ::boost::detail::is_lvalue_reference_helper2( - ::boost::detail::is_lvalue_reference_helper1(::boost::type_traits::wrap()))) == 1 - ); -}; - -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void,false) -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void const,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void volatile,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void const volatile,false) -#endif - -} // namespace detail - -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,::boost::detail::is_lvalue_reference_impl::value) - -#ifdef BOOST_MSVC -# pragma warning(pop) -#endif - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - } // namespace boost #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_member_function_pointer.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_member_function_pointer.hpp index 38babf43a..d1c3690ba 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_member_function_pointer.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_member_function_pointer.hpp @@ -14,8 +14,7 @@ #include #include -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ - && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) // // Note: we use the "workaround" version for MSVC because it works for // __stdcall etc function types, where as the partial specialisation @@ -39,7 +38,7 @@ namespace boost { #if defined( __CODEGEARC__ ) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,__is_member_function_pointer( T )) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_member_function_pointer @@ -92,10 +91,8 @@ struct is_member_function_pointer_impl { }; -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_member_function_pointer_impl : public false_type{}; -#endif #else // Borland C++ @@ -127,7 +124,7 @@ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const volatil BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,::boost::detail::is_member_function_pointer_impl::value) -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_member_pointer.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_member_pointer.hpp index a4a6d25a7..cba31af0c 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_member_pointer.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_member_pointer.hpp @@ -24,7 +24,7 @@ #include #include -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) # include #else # include @@ -46,7 +46,7 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,__is_member_pointer(T)) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::is_member_function_pointer::value) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) @@ -56,59 +56,8 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer, BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*const volatile,true) #endif -#else // no partial template specialization - -namespace detail { - -template -::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_tester(R T::*const volatile*); -::boost::type_traits::no_type BOOST_TT_DECL is_member_pointer_tester(...); - -template -struct is_member_pointer_select - : public ::boost::type_traits::false_result -{ -}; - -template <> -struct is_member_pointer_select -{ - template struct result_ - { - static T* make_t(); - BOOST_STATIC_CONSTANT( - bool, value = - (::boost::type_traits::ice_or< - (1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(make_t()))), - (1 == sizeof(is_member_pointer_tester(make_t()))) - >::value) ); - }; -}; - -template -struct is_member_pointer_impl - : public is_member_pointer_select< - ::boost::type_traits::ice_or< - ::boost::is_reference::value - , ::boost::is_array::value - >::value - >::template result_ -{ -}; - -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void,false) -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void volatile,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const volatile,false) #endif -} // namespace detail - -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::detail::is_member_pointer_impl::value) - -#endif // __BORLANDC__ - } // namespace boost #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_assignable.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_assignable.hpp index 5a3427f90..9188c6c01 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_assignable.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_assignable.hpp @@ -51,6 +51,15 @@ struct is_nothrow_move_assignable_imp{ >::value)); }; +#ifdef BOOST_NO_NOEXCEPT +// +// The above logic doesn't quite work in the absense of noexcept, +// this is really to improve things with VC13: +// +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#endif + #else template diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_constructible.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_constructible.hpp index bc7fb888c..c7218befa 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_constructible.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_nothrow_move_constructible.hpp @@ -66,6 +66,15 @@ struct is_nothrow_move_constructible_imp{ #endif +#ifdef BOOST_NO_NOEXCEPT +// +// The above logic doesn't quite work in the absense of noexcept, +// this is really to improve things with VC13: +// +template +struct is_nothrow_move_constructible_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; +#endif + } BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_nothrow_move_constructible,T,::boost::detail::is_nothrow_move_constructible_imp::value) diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_object.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_object.hpp index 3decbf8d1..1d1ae4f02 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_object.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_object.hpp @@ -26,20 +26,12 @@ namespace detail { template struct is_object_impl { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, ::boost::type_traits::ice_not< ::boost::is_void::value>::value, ::boost::type_traits::ice_not< ::boost::is_function::value>::value >::value)); -#else - BOOST_STATIC_CONSTANT(bool, value = - (::boost::type_traits::ice_and< - ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, - ::boost::type_traits::ice_not< ::boost::is_void::value>::value - >::value)); -#endif }; } // namespace detail diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_pod.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_pod.hpp index b4e173398..820a3ceeb 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_pod.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_pod.hpp @@ -33,7 +33,6 @@ template< typename T > struct is_POD; namespace detail { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_pod_impl { @@ -54,71 +53,6 @@ struct is_pod_impl }; #endif -#else - -template -struct is_pod_helper -{ - template struct result_ - { - BOOST_STATIC_CONSTANT( - bool, value = - (::boost::type_traits::ice_or< - ::boost::is_scalar::value, - ::boost::is_void::value, - BOOST_INTERNAL_IS_POD(T) - >::value)); - }; -}; - -template -struct bool_to_yes_no_type -{ - typedef ::boost::type_traits::no_type type; -}; - -template <> -struct bool_to_yes_no_type -{ - typedef ::boost::type_traits::yes_type type; -}; - -template -struct is_pod_array_helper -{ - enum { is_pod = ::boost::is_POD::value }; // MSVC workaround - typedef typename bool_to_yes_no_type::type type; - type instance() const; -}; - -template -is_pod_array_helper is_POD_array(T*); - -template <> -struct is_pod_helper -{ - template struct result_ - { - static T& help(); - BOOST_STATIC_CONSTANT(bool, value = - sizeof(is_POD_array(help()).instance()) == sizeof(::boost::type_traits::yes_type) - ); - }; -}; - - -template struct is_pod_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::detail::is_pod_helper< - ::boost::is_array::value - >::template result_::value - ) - ); -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // the following help compilers without partial specialization support: BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void,true) diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_pointer.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_pointer.hpp index 4e29bb39d..aad30f254 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_pointer.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_pointer.hpp @@ -25,17 +25,8 @@ #include #include #include -#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300) #include -#endif -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# include -# include -# include -# include -# include -#endif // should be the last #include #include @@ -44,7 +35,7 @@ namespace boost { #if defined( __CODEGEARC__ ) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,__is_pointer(T)) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else namespace detail { @@ -67,16 +58,6 @@ TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T*,true) template< typename T > struct is_pointer_impl { -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) - BOOST_STATIC_CONSTANT(bool, value = - (::boost::type_traits::ice_and< - ::boost::detail::is_pointer_helper::value - , ::boost::type_traits::ice_not< - ::boost::is_member_pointer::value - >::value - >::value) - ); -#else BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper::type>::value @@ -85,7 +66,6 @@ struct is_pointer_impl >::value >::value) ); -#endif }; } // namespace detail @@ -99,62 +79,8 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& volatile,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const volatile,false) #endif -#else // no partial template specialization - -namespace detail { - -struct pointer_helper -{ - pointer_helper(const volatile void*); -}; - -yes_type BOOST_TT_DECL is_pointer_tester(pointer_helper); -no_type BOOST_TT_DECL is_pointer_tester(...); - -template -struct is_pointer_select - : public ::boost::type_traits::false_result -{ -}; - -template <> -struct is_pointer_select -{ - template struct result_ - { - static T& make_t(); - BOOST_STATIC_CONSTANT(bool, value = - (::boost::type_traits::ice_or< - (1 == sizeof(is_pointer_tester(make_t()))), - (1 == sizeof(type_traits::is_function_ptr_tester(make_t()))) - >::value)); - }; -}; - -template -struct is_pointer_impl - : public is_pointer_select< - ::boost::type_traits::ice_or< - ::boost::is_reference::value - , ::boost::is_array::value - >::value - >::template result_ -{ -}; - -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void,false) -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void volatile,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const volatile,false) #endif -} // namespace detail - -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl::value) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - } // namespace boost #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_polymorphic.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_polymorphic.hpp index 8fcc69eb2..aac985105 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_polymorphic.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_polymorphic.hpp @@ -17,6 +17,11 @@ #include #include +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700) +#pragma warning(push) +#pragma warning(disable:4250) +#endif + namespace boost{ #ifndef BOOST_IS_POLYMORPHIC @@ -111,4 +116,8 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_polymorphic,T,BOOST_IS_POLYMORPHIC(T)) #include +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700) +#pragma warning(pop) +#endif + #endif diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_same.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_same.hpp index c6afbd7f0..c8987b07a 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_same.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_same.hpp @@ -22,17 +22,11 @@ #define BOOST_TT_IS_SAME_HPP_INCLUDED #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#include -#include -#endif // should be the last #include #include namespace boost { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T,T,true) @@ -42,58 +36,6 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T,T,true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T&,T&,true) #endif -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -namespace detail { - -#ifdef BOOST_MSVC -// the following VC6 specific implementation is *NOT* legal -// C++, but has the advantage that it works for incomplete -// types. - -template< typename T1 > -struct is_same_part_1 -{ - template struct part_2 { enum { value = false }; }; - template<> struct part_2 { enum { value = true }; }; -}; - -template< typename T1, typename T2 > -struct is_same_impl -{ - enum { value = boost::detail::is_same_part_1::template part_2::value }; -}; - -#else // generic "no-partial-specialization" version - -template -::boost::type_traits::yes_type -BOOST_TT_DECL is_same_tester(T*, T*); - -::boost::type_traits::no_type -BOOST_TT_DECL is_same_tester(...); - -template -struct is_same_impl -{ - static T t; - static U u; - - BOOST_STATIC_CONSTANT(bool, value = - (::boost::type_traits::ice_and< - (sizeof(type_traits::yes_type) == sizeof(boost::detail::is_same_tester(&t,&u))), - (::boost::is_reference::value == ::boost::is_reference::value), - (sizeof(T) == sizeof(U)) - >::value)); -}; - -#endif // BOOST_MSVC - -} // namespace detail - -BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,(::boost::detail::is_same_impl::value)) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_signed.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_signed.hpp index ba7d6e97c..567328494 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_signed.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_signed.hpp @@ -76,11 +76,7 @@ struct is_signed_imp > selector; typedef typename selector::template rebind binder; typedef typename binder::type type; -#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) - BOOST_STATIC_CONSTANT(bool, value = is_signed_imp::type::value); -#else BOOST_STATIC_CONSTANT(bool, value = type::value); -#endif }; #else diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_virtual_base_of.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_virtual_base_of.hpp index f57cb6187..33db914d3 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_virtual_base_of.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_virtual_base_of.hpp @@ -91,11 +91,9 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF2( , (::boost::detail::is_virtual_base_of_impl2::value) ) -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base&,Derived,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base,Derived&,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base&,Derived&,false) -#endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/is_volatile.hpp b/src/thirdparty/boost_lib/boost/type_traits/is_volatile.hpp index c921c9ef3..d9839dad3 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/is_volatile.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/is_volatile.hpp @@ -24,17 +24,10 @@ #include #include -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include # if BOOST_WORKAROUND(BOOST_MSVC, < 1400) # include # endif -#else -# include -# include -# include -# include -#endif // should be the last #include #include @@ -48,7 +41,7 @@ struct is_volatile_rval_filter #if BOOST_WORKAROUND(BOOST_MSVC, < 1400) BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::type*>::is_volatile); #else - BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::is_volatile); + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::is_volatile); #endif }; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES @@ -66,7 +59,7 @@ struct is_volatile_rval_filter #if defined( __CODEGEARC__ ) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,__is_volatile(T)) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else //* is a type T declared volatile - is_volatile BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_rval_filter::value) @@ -82,69 +75,8 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& volatile,false BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const volatile,false) #endif -#else - -namespace detail { - -using ::boost::type_traits::yes_type; -using ::boost::type_traits::no_type; - -yes_type is_volatile_tester(void const volatile*); -no_type is_volatile_tester(void const*); - -template -struct is_volatile_helper - : public ::boost::type_traits::false_result -{ -}; - -template <> -struct is_volatile_helper -{ - template struct result_ - { - static T* t; - BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_volatile_tester(t)) - )); - }; -}; - -template <> -struct is_volatile_helper -{ - template struct result_ - { - static T t; - BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_volatile_tester(&t)) - )); - }; -}; - -template -struct is_volatile_impl - : public is_volatile_helper< - is_reference::value - , is_array::value - >::template result_ -{ -}; - -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void,false) -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void volatile,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const volatile,true) #endif -} // namespace detail - -//* is a type T declared volatile - is_volatile -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_impl::value) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - } // namespace boost #include diff --git a/src/thirdparty/boost_lib/boost/type_traits/make_signed.hpp b/src/thirdparty/boost_lib/boost/type_traits/make_signed.hpp index 7deb85557..51cdbb0dc 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/make_signed.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/make_signed.hpp @@ -37,11 +37,9 @@ struct make_signed_imp { BOOST_STATIC_ASSERT( (::boost::type_traits::ice_or< ::boost::is_integral::value, ::boost::is_enum::value>::value)); -#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300) BOOST_STATIC_ASSERT( (::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv::type, bool>::value>::value)); -#endif typedef typename remove_cv::type t_no_cv; typedef typename mpl::if_c< diff --git a/src/thirdparty/boost_lib/boost/type_traits/make_unsigned.hpp b/src/thirdparty/boost_lib/boost/type_traits/make_unsigned.hpp index 7e2fcdc45..239153a86 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/make_unsigned.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/make_unsigned.hpp @@ -37,11 +37,9 @@ struct make_unsigned_imp { BOOST_STATIC_ASSERT( (::boost::type_traits::ice_or< ::boost::is_integral::value, ::boost::is_enum::value>::value)); -#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300) BOOST_STATIC_ASSERT( (::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv::type, bool>::value>::value)); -#endif typedef typename remove_cv::type t_no_cv; typedef typename mpl::if_c< diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_all_extents.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_all_extents.hpp deleted file mode 100644 index 25c0edfaa..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_all_extents.hpp +++ /dev/null @@ -1,47 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_ALL_EXTENT_HOLT_2004_0827 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_ALL_EXTENT_HOLT_2004_0827 - -#include -#include - -namespace boost { - template - struct remove_all_extents; - - namespace detail { - template - struct remove_all_extents_impl_typeof { - template - struct inner { - typedef T type; - }; - }; - template<> - struct remove_all_extents_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U[]); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) )); - typedef typename msvc_extract_type::id2type::type reduced_type; - typedef typename remove_all_extents::type type; - }; - }; - } //namespace detail - - template - struct remove_all_extents { - typedef typename boost::detail::remove_all_extents_impl_typeof< - boost::is_array::value - >::template inner >::type type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_all_extents,T) - }; -} //namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827 - diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_bounds.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_bounds.hpp deleted file mode 100644 index 4b23b3527..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_bounds.hpp +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827 - -#include -#include - -namespace boost { - namespace detail { - template - struct remove_bounds_impl_typeof { - template - struct inner { - typedef T type; - }; - }; - template<> - struct remove_bounds_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U[]); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - }; - } //namespace detail - - template - struct remove_bounds { - typedef typename boost::detail::remove_bounds_impl_typeof< - boost::is_array::value - >::template inner >::type type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_bounds,T) - }; -} //namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827 - diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_const.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_const.hpp deleted file mode 100644 index d370754ad..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_const.hpp +++ /dev/null @@ -1,143 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828 - -#include -#include -#include -#include -#include - -namespace boost { - namespace detail { - template - struct remove_const_impl_typeof { - template - struct inner { - typedef T type; - }; - template - struct transform_type { - typedef T type; - }; - }; - template<> //Const - struct remove_const_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U const&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //CV - struct remove_const_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U const volatile&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //Const Pointer - struct remove_const_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U const[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //CV Pointer - struct remove_const_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U const volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //Const Array - struct remove_const_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U const[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - - template<> //CV Array - struct remove_const_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U const volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - - } //namespace detail - - template - struct remove_const { - typedef boost::detail::remove_const_impl_typeof< - boost::is_pointer::value, - boost::is_array::value, - boost::is_const::value, - boost::is_volatile::value - > remove_const_type; - typedef typename - remove_const_type::template inner< - typename remove_const_type::template transform_type::type, - remove_const - >::type - type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_const,T) - }; -}//namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828 diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_cv.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_cv.hpp deleted file mode 100644 index 9fbf8b845..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_cv.hpp +++ /dev/null @@ -1,190 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901 - -#include -#include -#include -#include -#include - -namespace boost { - namespace detail { - template - struct remove_cv_impl_typeof { - template - struct inner { - typedef T type; - }; - template - struct transform_type { - typedef T type; - }; - }; - template<> //Volatile - struct remove_cv_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U volatile&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //Const - struct remove_cv_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U const&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //CV - struct remove_cv_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U const volatile&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //Volatile Pointer - struct remove_cv_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //Const Pointer - struct remove_cv_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U const[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //CV Pointer - struct remove_cv_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U const volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //Volatile Array - struct remove_cv_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - template<> //Const Array - struct remove_cv_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U const[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - - template<> //CV Array - struct remove_cv_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U const volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - - } //namespace detail - - template - struct remove_cv { - typedef boost::detail::remove_cv_impl_typeof< - boost::is_pointer::value, - boost::is_array::value, - boost::is_const::value, - boost::is_volatile::value - > remove_cv_type; - typedef typename - remove_cv_type::template inner< - typename remove_cv_type::template transform_type::type, - remove_cv - >::type - type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_cv,T) - }; -}//namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901 diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_extent.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_extent.hpp deleted file mode 100644 index c5a59ef6f..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_extent.hpp +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_EXTENT_HOLT_2004_0827 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_EXTENT_HOLT_2004_0827 - -#include -#include - -namespace boost { - namespace detail { - template - struct remove_extent_impl_typeof { - template - struct inner { - typedef T type; - }; - }; - template<> - struct remove_extent_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U[]); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - }; - } //namespace detail - - template - struct remove_extent { - typedef typename boost::detail::remove_extent_impl_typeof< - boost::is_array::value - >::template inner >::type type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_extent,T) - }; -} //namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827 - diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_pointer.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_pointer.hpp deleted file mode 100644 index ec847f9d8..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_pointer.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_POINTER_HOLT_2004_0827 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_POINTER_HOLT_2004_0827 - -#include -#include - -namespace boost { - namespace detail { - template - struct remove_pointer_impl_typeof { - template - struct inner { - typedef T type; - }; - }; - template<> - struct remove_pointer_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U*); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - }; - } //namespace detail - - template - struct remove_pointer { - typedef typename boost::detail::remove_pointer_impl_typeof< - boost::is_pointer::value - >::template inner >::type type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_pointer,T) - }; -} //namespace boost - -#endif //BOOST_TYPE_TRAITS_REMOVE_POINTER_HOLT_2004_0827 diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_reference.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_reference.hpp deleted file mode 100644 index f8a77d4c5..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_reference.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827 - -#include -#include - -namespace boost { - namespace detail { - template - struct remove_reference_impl_typeof { - template - struct inner { - typedef T type; - }; - }; - template<> - struct remove_reference_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - }; - } //namespace detail - - template - struct remove_reference { - typedef typename boost::detail::remove_reference_impl_typeof< - boost::is_reference::value - >::template inner >::type type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_reference,T) - }; -} //namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827 diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_volatile.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_volatile.hpp deleted file mode 100644 index 6f9259c5b..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/remove_volatile.hpp +++ /dev/null @@ -1,143 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828 -#define BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828 - -#include -#include -#include -#include -#include - -namespace boost { - namespace detail { - template - struct remove_volatile_impl_typeof { - template - struct inner { - typedef T type; - }; - template - struct transform_type { - typedef T type; - }; - }; - template<> //Volatile - struct remove_volatile_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U volatile&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //CV - struct remove_volatile_impl_typeof { - template - struct inner { - template - static msvc_register_type test(U const volatile&(*)()); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T& type; - }; - }; - template<> //Volatile Pointer - struct remove_volatile_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //CV Pointer - struct remove_volatile_impl_typeof { - template - struct inner { - template - static msvc_register_type test(void(*)(U const volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type[]; - }; - }; - template<> //Volatile Array - struct remove_volatile_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - - template<> //CV Array - struct remove_volatile_impl_typeof { - template - struct inner { - BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0]))); - - template - static msvc_register_type test(void(*)(U const volatile[])); - static msvc_register_type test(...); - BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) )); - typedef typename msvc_extract_type::id2type::type type; - }; - template - struct transform_type { - typedef T type; - }; - }; - - } //namespace detail - - template - struct remove_volatile { - typedef boost::detail::remove_volatile_impl_typeof< - boost::is_pointer::value, - boost::is_array::value, - boost::is_const::value, - boost::is_volatile::value - > remove_volatile_type; - typedef typename - remove_volatile_type::template inner< - typename remove_volatile_type::template transform_type::type, - remove_volatile - >::type - type; - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_volatile,T) - }; -}//namespace boost - -#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828 diff --git a/src/thirdparty/boost_lib/boost/type_traits/msvc/typeof.hpp b/src/thirdparty/boost_lib/boost/type_traits/msvc/typeof.hpp deleted file mode 100644 index b95785d52..000000000 --- a/src/thirdparty/boost_lib/boost/type_traits/msvc/typeof.hpp +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright (C) 2004 Peder Holt -// Use, modification and distribution is subject to the Boost Software -// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_TYPETRAITS_MSVC_TYPEOF_HPP -#define BOOST_TYPETRAITS_MSVC_TYPEOF_HPP - -#include -#include - -namespace boost { namespace detail { -# if BOOST_WORKAROUND(BOOST_MSVC,==1300) - template - struct msvc_extract_type - { - template - struct id2type_impl; - - typedef id2type_impl id2type; - }; - - template - struct msvc_register_type : public msvc_extract_type - { - template<> - struct id2type_impl //VC7.0 specific bugfeature - { - typedef T type; - }; - }; -# else - template - struct msvc_extract_type - { - struct id2type; - }; - - template - struct msvc_register_type : public msvc_extract_type - { - typedef msvc_extract_type base_type; - struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature - { - typedef T type; - }; - }; -# endif -}} - -#endif //BOOST_TYPETRAITS_MSVC_TYPEOF_IMPL_HPP diff --git a/src/thirdparty/boost_lib/boost/type_traits/rank.hpp b/src/thirdparty/boost_lib/boost/type_traits/rank.hpp index 77df41e84..33f46c8eb 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/rank.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/rank.hpp @@ -24,7 +24,7 @@ struct rank_imp { BOOST_STATIC_CONSTANT(std::size_t, value = N); }; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template struct rank_imp { diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_all_extents.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_all_extents.hpp index 64876e19a..1409da12c 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_all_extents.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_all_extents.hpp @@ -13,20 +13,14 @@ #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include -#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - namespace boost { BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_all_extents,T,T) -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T[N],typename boost::remove_all_extents::type type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T const[N],typename boost::remove_all_extents::type type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T volatile[N],typename boost::remove_all_extents::type type) @@ -41,8 +35,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_all_extents,T const vo } // namespace boost -#endif - #include #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_bounds.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_bounds.hpp index ce1297873..2d26348c6 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_bounds.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_bounds.hpp @@ -13,20 +13,14 @@ #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include -#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - namespace boost { BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_bounds,T,T) -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T[N],T type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const[N],T const type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T volatile[N],T volatile type) @@ -41,8 +35,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const volatil } // namespace boost -#endif - #include #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_const.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_const.hpp index 5f957e978..102078138 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_const.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_const.hpp @@ -12,23 +12,17 @@ #define BOOST_TT_REMOVE_CONST_HPP_INCLUDED #include -#include #include #include #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include namespace boost { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { @@ -49,7 +43,7 @@ template struct remove_const_impl { typedef typename remove_const_helper< - typename cv_traits_imp::unqualified_type + typename cv_traits_imp::unqualified_type , ::boost::is_volatile::value >::type type; }; @@ -77,11 +71,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const volatile[N],T volatile type[N]) #endif -#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename boost::detail::remove_const_impl::type) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_cv.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_cv.hpp index 7478c207e..9ba34a1ef 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_cv.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_cv.hpp @@ -11,30 +11,24 @@ #ifndef BOOST_TT_REMOVE_CV_HPP_INCLUDED #define BOOST_TT_REMOVE_CV_HPP_INCLUDED -#include #include #include #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include namespace boost { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail{ template struct rvalue_ref_filter_rem_cv { - typedef typename boost::detail::cv_traits_imp::unqualified_type type; + typedef typename boost::detail::cv_traits_imp::unqualified_type type; }; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES @@ -61,21 +55,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T vol BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const volatile[N],T type[N]) #endif -#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - -namespace detail { -template -struct remove_cv_impl -{ - typedef typename remove_volatile_impl< - typename remove_const_impl::type - >::type type; -}; -} - -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename boost::detail::remove_cv_impl::type) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_extent.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_extent.hpp index b4c7d4136..9c4cdff70 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_extent.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_extent.hpp @@ -13,20 +13,14 @@ #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include -#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - namespace boost { BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_extent,T,T) -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T[N],T type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T const[N],T const type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T volatile[N],T volatile type) @@ -41,8 +35,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_extent,T const volatil } // namespace boost -#endif - #include #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_pointer.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_pointer.hpp index 01253db8f..fef706860 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_pointer.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_pointer.hpp @@ -11,13 +11,8 @@ #include #include -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include -#endif -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#elif defined(BOOST_MSVC) +#if defined(BOOST_MSVC) #include #include #endif @@ -71,7 +66,7 @@ namespace detail{ BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename boost::detail::remove_pointer_imp2::type) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#else BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T*,T) @@ -79,10 +74,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* volatile,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const volatile,T) -#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename boost::detail::remove_pointer_impl::type) - #endif } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_reference.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_reference.hpp index 19a55b738..c59e7e35f 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_reference.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_reference.hpp @@ -9,20 +9,14 @@ #ifndef BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED #define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED -#include #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include namespace boost { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail{ // @@ -57,11 +51,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& volatile, BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const volatile,T) #endif -#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename boost::detail::remove_reference_impl::type) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/remove_volatile.hpp b/src/thirdparty/boost_lib/boost/type_traits/remove_volatile.hpp index 98da5cfc1..c20277696 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/remove_volatile.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/remove_volatile.hpp @@ -12,23 +12,17 @@ #define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED #include -#include #include #include #include #include -#if BOOST_WORKAROUND(BOOST_MSVC,<=1300) -#include -#endif - // should be the last #include #include namespace boost { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { @@ -48,7 +42,7 @@ template struct remove_volatile_impl { typedef typename remove_volatile_helper< - typename cv_traits_imp::unqualified_type + typename cv_traits_imp::unqualified_type , ::boost::is_const::value >::type type; }; @@ -75,11 +69,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T const volatile[N],T const type[N]) #endif -#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300) - -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename boost::detail::remove_volatile_impl::type) - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/type_traits/transform_traits_spec.hpp b/src/thirdparty/boost_lib/boost/type_traits/transform_traits_spec.hpp index 851af3d39..b12b5f8e5 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/transform_traits_spec.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/transform_traits_spec.hpp @@ -6,9 +6,9 @@ // // See http://www.boost.org/libs/type_traits for most recent version including documentation. -#ifndef BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP_INCLUDED -#define BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP_INCLUDED +#ifndef BOOST_TT_TRANSFORM_TRAITS_HPP_INCLUDED +#define BOOST_TT_TRANSFORM_TRAITS_HPP_INCLUDED -#include +#include -#endif // BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP_INCLUDED +#endif diff --git a/src/thirdparty/boost_lib/boost/type_traits/type_with_alignment.hpp b/src/thirdparty/boost_lib/boost/type_traits/type_with_alignment.hpp index a86137f53..ad86613fd 100644 --- a/src/thirdparty/boost_lib/boost/type_traits/type_with_alignment.hpp +++ b/src/thirdparty/boost_lib/boost/type_traits/type_with_alignment.hpp @@ -69,35 +69,6 @@ typedef int (alignment_dummy::*member_function_ptr)(); // This template gets instantiated a lot, so use partial // specialization when available to reduce the compiler burden. // -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -template -struct lower_alignment_helper_impl -{ - template - struct apply - { - typedef char type; - enum { value = true }; - }; -}; - -template <> -struct lower_alignment_helper_impl -{ - template - struct apply - : public mpl::if_c<(alignment_of::value == target), TestType, char> - { - enum { value = (alignment_of::value == target) }; - }; -}; - -template -struct lower_alignment_helper - : public lower_alignment_helper_impl::template apply -{ -}; -#else template struct lower_alignment_helper { @@ -111,7 +82,6 @@ struct lower_alignment_helper enum { value = (alignment_of::value == target) }; typedef typename mpl::if_c::type type; }; -#endif #define BOOST_TT_CHOOSE_MIN_ALIGNMENT(R,P,I,T) \ typename lower_alignment_helper< \ @@ -166,26 +136,14 @@ struct is_aligned ); }; -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::max_align,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<1> ,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<2> ,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<4> ,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<8> ,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<10> ,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<16> ,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<32> ,true) -#endif } // namespace detail -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_pod< ::boost::detail::lower_alignment > { BOOST_STATIC_CONSTANT(std::size_t, value = true); }; -#endif // This alignment method originally due to Brian Parker, implemented by David // Abrahams, and then ported here by Doug Gregor. @@ -219,7 +177,7 @@ class type_with_alignment }; #if defined(__GNUC__) -namespace align { +namespace tt_align_ns { struct __attribute__((__aligned__(2))) a2 {}; struct __attribute__((__aligned__(4))) a4 {}; struct __attribute__((__aligned__(8))) a8 {}; @@ -230,25 +188,25 @@ struct __attribute__((__aligned__(128))) a128 {}; } template<> class type_with_alignment<1> { public: typedef char type; }; -template<> class type_with_alignment<2> { public: typedef align::a2 type; }; -template<> class type_with_alignment<4> { public: typedef align::a4 type; }; -template<> class type_with_alignment<8> { public: typedef align::a8 type; }; -template<> class type_with_alignment<16> { public: typedef align::a16 type; }; -template<> class type_with_alignment<32> { public: typedef align::a32 type; }; -template<> class type_with_alignment<64> { public: typedef align::a64 type; }; -template<> class type_with_alignment<128> { public: typedef align::a128 type; }; +template<> class type_with_alignment<2> { public: typedef tt_align_ns::a2 type; }; +template<> class type_with_alignment<4> { public: typedef tt_align_ns::a4 type; }; +template<> class type_with_alignment<8> { public: typedef tt_align_ns::a8 type; }; +template<> class type_with_alignment<16> { public: typedef tt_align_ns::a16 type; }; +template<> class type_with_alignment<32> { public: typedef tt_align_ns::a32 type; }; +template<> class type_with_alignment<64> { public: typedef tt_align_ns::a64 type; }; +template<> class type_with_alignment<128> { public: typedef tt_align_ns::a128 type; }; namespace detail { -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a32,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a64,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a2,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a4,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a32,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a64,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a128,true) } #endif -#if (defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && _MSC_VER >= 1300 +#if defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER)) // // MSVC supports types which have alignments greater than the normal // maximum: these are used for example in the types __m64 and __m128 @@ -265,7 +223,7 @@ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true) // Boost.Optional). However, this only happens when we have no choice // in the matter because no other "ordinary" type is available. // -namespace align { +namespace tt_align_ns { struct __declspec(align(8)) a8 { char m[8]; typedef a8 type; @@ -293,7 +251,7 @@ template<> class type_with_alignment<8> { typedef mpl::if_c< ::boost::alignment_of::value < 8, - align::a8, + tt_align_ns::a8, boost::detail::type_with_alignment_imp<8> >::type t1; public: typedef t1::type type; @@ -302,7 +260,7 @@ template<> class type_with_alignment<16> { typedef mpl::if_c< ::boost::alignment_of::value < 16, - align::a16, + tt_align_ns::a16, boost::detail::type_with_alignment_imp<16> >::type t1; public: typedef t1::type type; @@ -311,7 +269,7 @@ template<> class type_with_alignment<32> { typedef mpl::if_c< ::boost::alignment_of::value < 32, - align::a32, + tt_align_ns::a32, boost::detail::type_with_alignment_imp<32> >::type t1; public: typedef t1::type type; @@ -319,7 +277,7 @@ template<> class type_with_alignment<32> template<> class type_with_alignment<64> { typedef mpl::if_c< ::boost::alignment_of::value < 64, - align::a64, + tt_align_ns::a64, boost::detail::type_with_alignment_imp<64> >::type t1; public: typedef t1::type type; @@ -327,18 +285,18 @@ template<> class type_with_alignment<64> { template<> class type_with_alignment<128> { typedef mpl::if_c< ::boost::alignment_of::value < 128, - align::a128, + tt_align_ns::a128, boost::detail::type_with_alignment_imp<128> >::type t1; public: typedef t1::type type; }; namespace detail { -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a32,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a64,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a32,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a64,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a128,true) } #endif @@ -350,7 +308,7 @@ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true) // 2) Because of Borlands #pragma option we can create types with alignments that are // greater that the largest aligned builtin type. -namespace align{ +namespace tt_align_ns{ #pragma option push -a16 struct a2{ short s; }; struct a4{ int s; }; @@ -361,13 +319,13 @@ struct a16{ long double s; }; namespace detail { -typedef ::boost::align::a16 max_align; +typedef ::boost::tt_align_ns::a16 max_align; //#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a2,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a4,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true) //#endif } @@ -376,13 +334,13 @@ template struct type_with_alignment // We should never get to here, but if we do use the maximally // aligned type: // BOOST_STATIC_ASSERT(0); - typedef align::a16 type; + typedef tt_align_ns::a16 type; }; template <> struct type_with_alignment<1>{ typedef char type; }; -template <> struct type_with_alignment<2>{ typedef align::a2 type; }; -template <> struct type_with_alignment<4>{ typedef align::a4 type; }; -template <> struct type_with_alignment<8>{ typedef align::a8 type; }; -template <> struct type_with_alignment<16>{ typedef align::a16 type; }; +template <> struct type_with_alignment<2>{ typedef tt_align_ns::a2 type; }; +template <> struct type_with_alignment<4>{ typedef tt_align_ns::a4 type; }; +template <> struct type_with_alignment<8>{ typedef tt_align_ns::a8 type; }; +template <> struct type_with_alignment<16>{ typedef tt_align_ns::a16 type; }; #endif diff --git a/src/thirdparty/boost_lib/boost/unordered_map.hpp b/src/thirdparty/boost_lib/boost/unordered_map.hpp index 00d3c91c2..92ef4d601 100644 --- a/src/thirdparty/boost_lib/boost/unordered_map.hpp +++ b/src/thirdparty/boost_lib/boost/unordered_map.hpp @@ -9,8 +9,9 @@ #ifndef BOOST_UNORDERED_MAP_HPP_INCLUDED #define BOOST_UNORDERED_MAP_HPP_INCLUDED -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once #endif #include diff --git a/src/thirdparty/boost_lib/boost/unordered_set.hpp b/src/thirdparty/boost_lib/boost/unordered_set.hpp index 98c3ce1d7..1c83c02b2 100644 --- a/src/thirdparty/boost_lib/boost/unordered_set.hpp +++ b/src/thirdparty/boost_lib/boost/unordered_set.hpp @@ -9,8 +9,9 @@ #ifndef BOOST_UNORDERED_SET_HPP_INCLUDED #define BOOST_UNORDERED_SET_HPP_INCLUDED -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once #endif #include diff --git a/src/thirdparty/boost_lib/boost/utility/addressof.hpp b/src/thirdparty/boost_lib/boost/utility/addressof.hpp index ecb77764e..db4da8042 100644 --- a/src/thirdparty/boost_lib/boost/utility/addressof.hpp +++ b/src/thirdparty/boost_lib/boost/utility/addressof.hpp @@ -1,102 +1,17 @@ -// Copyright (C) 2002 Brad King (brad.king@kitware.com) -// Douglas Gregor (gregod@cs.rpi.edu) -// -// Copyright (C) 2002, 2008 Peter Dimov -// -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -// For more information, see http://www.boost.org +/* + * Copyright (c) 2014 Glen Fernandes + * + * Distributed under the Boost Software License, Version 1.0. (See + * accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ #ifndef BOOST_UTILITY_ADDRESSOF_HPP -# define BOOST_UTILITY_ADDRESSOF_HPP - -# include -# include - -namespace boost -{ - -namespace detail -{ - -template struct addr_impl_ref -{ - T & v_; - - inline addr_impl_ref( T & v ): v_( v ) {} - inline operator T& () const { return v_; } - -private: - addr_impl_ref & operator=(const addr_impl_ref &); -}; - -template struct addressof_impl -{ - static inline T * f( T & v, long ) - { - return reinterpret_cast( - &const_cast(reinterpret_cast(v))); - } - - static inline T * f( T * v, int ) - { - return v; - } -}; - -} // namespace detail - -template T * addressof( T & v ) -{ -#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC ) - - return boost::detail::addressof_impl::f( v, 0 ); +#define BOOST_UTILITY_ADDRESSOF_HPP -#else +// The header file at this path is deprecated; +// use boost/core/addressof.hpp instead. - return boost::detail::addressof_impl::f( boost::detail::addr_impl_ref( v ), 0 ); +#include #endif -} - -#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) ) - -namespace detail -{ - -template struct addressof_addp -{ - typedef T * type; -}; - -} // namespace detail - -template< class T, std::size_t N > -typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] ) -{ - return &t; -} - -#endif - -// Borland doesn't like casting an array reference to a char reference -// but these overloads work around the problem. -#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -template -T (*addressof(T (&t)[N]))[N] -{ - return reinterpret_cast(&t); -} - -template -const T (*addressof(const T (&t)[N]))[N] -{ - return reinterpret_cast(&t); -} -#endif - -} // namespace boost - -#endif // BOOST_UTILITY_ADDRESSOF_HPP diff --git a/src/thirdparty/boost_lib/boost/utility/base_from_member.hpp b/src/thirdparty/boost_lib/boost/utility/base_from_member.hpp index e32ecb8d9..fc0e13c0d 100644 --- a/src/thirdparty/boost_lib/boost/utility/base_from_member.hpp +++ b/src/thirdparty/boost_lib/boost/utility/base_from_member.hpp @@ -148,6 +148,19 @@ class base_from_member }; // boost::base_from_member +template < typename MemberType, int UniqueID > +class base_from_member +{ +protected: + MemberType& member; + + explicit BOOST_CONSTEXPR base_from_member( MemberType& x ) + BOOST_NOEXCEPT + : member( x ) + {} + +}; // boost::base_from_member + } // namespace boost diff --git a/src/thirdparty/boost_lib/boost/utility/empty_deleter.hpp b/src/thirdparty/boost_lib/boost/utility/empty_deleter.hpp index ba919cd2c..91bc47b81 100644 --- a/src/thirdparty/boost_lib/boost/utility/empty_deleter.hpp +++ b/src/thirdparty/boost_lib/boost/utility/empty_deleter.hpp @@ -4,6 +4,7 @@ * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) */ + /*! * \file empty_deleter.hpp * \author Andrey Semashev @@ -16,28 +17,27 @@ * deleted (i.e. a variable on the stack or some global singleton, like std::cout). */ -#ifndef BOOST_UTILITY_EMPTY_DELETER_HPP_INCLUDED_ -#define BOOST_UTILITY_EMPTY_DELETER_HPP_INCLUDED_ +#ifndef BOOST_UTILITY_EMPTY_DELETER_HPP +#define BOOST_UTILITY_EMPTY_DELETER_HPP #include +#include #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif +#if defined(__GNUC__) +#pragma message "This header is deprecated, use boost/core/null_deleter.hpp instead." +#elif defined(_MSC_VER) +#pragma message("This header is deprecated, use boost/core/null_deleter.hpp instead.") +#endif + namespace boost { -//! A function object that does nothing and can be used as an empty deleter for \c shared_ptr -struct empty_deleter -{ - //! Function object result type - typedef void result_type; - /*! - * Does nothing - */ - void operator() (const volatile void*) const BOOST_NOEXCEPT {} -}; +//! A deprecated name for \c null_deleter +typedef null_deleter empty_deleter; } // namespace boost -#endif // BOOST_UTILITY_EMPTY_DELETER_HPP_INCLUDED_ +#endif // BOOST_UTILITY_EMPTY_DELETER_HPP diff --git a/src/thirdparty/boost_lib/boost/utility/enable_if.hpp b/src/thirdparty/boost_lib/boost/utility/enable_if.hpp index d292c6a7b..803bfca5e 100644 --- a/src/thirdparty/boost_lib/boost/utility/enable_if.hpp +++ b/src/thirdparty/boost_lib/boost/utility/enable_if.hpp @@ -1,119 +1,17 @@ -// Boost enable_if library - -// Copyright 2003 (c) The Trustees of Indiana University. - -// 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) - -// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) -// Jeremiah Willcock (jewillco at osl.iu.edu) -// Andrew Lumsdaine (lums at osl.iu.edu) - +/* + * Copyright (c) 2014 Glen Fernandes + * + * Distributed under the Boost Software License, Version 1.0. (See + * accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ #ifndef BOOST_UTILITY_ENABLE_IF_HPP #define BOOST_UTILITY_ENABLE_IF_HPP -#include "boost/config.hpp" - -// Even the definition of enable_if causes problems on some compilers, -// so it's macroed out for all compilers that do not support SFINAE - -#ifndef BOOST_NO_SFINAE - -namespace boost -{ - - template - struct enable_if_c { - typedef T type; - }; - - template - struct enable_if_c {}; - - template - struct enable_if : public enable_if_c {}; - - template - struct lazy_enable_if_c { - typedef typename T::type type; - }; - - template - struct lazy_enable_if_c {}; - - template - struct lazy_enable_if : public lazy_enable_if_c {}; - - - template - struct disable_if_c { - typedef T type; - }; - - template - struct disable_if_c {}; - - template - struct disable_if : public disable_if_c {}; - - template - struct lazy_disable_if_c { - typedef typename T::type type; - }; - - template - struct lazy_disable_if_c {}; - - template - struct lazy_disable_if : public lazy_disable_if_c {}; - -} // namespace boost - -#else - -namespace boost { - - namespace detail { typedef void enable_if_default_T; } - - template - struct enable_if_does_not_work_on_this_compiler; - - template - struct enable_if_c : enable_if_does_not_work_on_this_compiler - { }; - - template - struct disable_if_c : enable_if_does_not_work_on_this_compiler - { }; - - template - struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler - { }; - - template - struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler - { }; - - template - struct enable_if : enable_if_does_not_work_on_this_compiler - { }; - - template - struct disable_if : enable_if_does_not_work_on_this_compiler - { }; - - template - struct lazy_enable_if : enable_if_does_not_work_on_this_compiler - { }; - - template - struct lazy_disable_if : enable_if_does_not_work_on_this_compiler - { }; - -} // namespace boost +// The header file at this path is deprecated; +// use boost/core/enable_if.hpp instead. -#endif // BOOST_NO_SFINAE +#include #endif diff --git a/src/thirdparty/boost_lib/boost/utility/explicit_operator_bool.hpp b/src/thirdparty/boost_lib/boost/utility/explicit_operator_bool.hpp index 650caff3a..9b625cd68 100644 --- a/src/thirdparty/boost_lib/boost/utility/explicit_operator_bool.hpp +++ b/src/thirdparty/boost_lib/boost/utility/explicit_operator_bool.hpp @@ -1,128 +1,17 @@ /* - * Copyright Andrey Semashev 2007 - 2013. - * 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) - */ -/*! - * \file explicit_operator_bool.hpp - * \author Andrey Semashev - * \date 08.03.2009 - * - * This header defines a compatibility macro that implements an unspecified - * \c bool operator idiom, which is superseded with explicit conversion operators in - * C++11. - */ - -#ifndef BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP_INCLUDED_ -#define BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP_INCLUDED_ - -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - -/*! - * \brief The macro defines an explicit operator of conversion to \c bool + * Copyright (c) 2014 Glen Fernandes * - * The macro should be used inside the definition of a class that has to - * support the conversion. The class should also implement operator!, - * in terms of which the conversion operator will be implemented. + * 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) */ -#define BOOST_EXPLICIT_OPERATOR_BOOL()\ - BOOST_FORCEINLINE explicit operator bool () const\ - {\ - return !this->operator! ();\ - } - -/*! - * \brief The macro defines a constexpr explicit operator of conversion to \c bool - * - * The macro should be used inside the definition of a class that has to - * support the conversion. The class should also implement operator!, - * in terms of which the conversion operator will be implemented. - */ -#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ - BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const\ - {\ - return !this->operator! ();\ - } - -#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - -#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG) -// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it -#define BOOST_NO_UNSPECIFIED_BOOL -#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG) -#if !defined(BOOST_NO_UNSPECIFIED_BOOL) +#ifndef BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP +#define BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP -namespace boost { +// The header file at this path is deprecated; +// use boost/core/explicit_operator_bool.hpp instead. -namespace detail { - -#if !defined(_MSC_VER) && !defined(__IBMCPP__) - - struct unspecified_bool - { - // NOTE TO THE USER: If you see this in error messages then you tried - // to apply an unsupported operator on the object that supports - // explicit conversion to bool. - struct OPERATORS_NOT_ALLOWED; - static void true_value(OPERATORS_NOT_ALLOWED*) {} - }; - typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*); - -#else - - // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't - struct unspecified_bool - { - // NOTE TO THE USER: If you see this in error messages then you tried - // to apply an unsupported operator on the object that supports - // explicit conversion to bool. - struct OPERATORS_NOT_ALLOWED; - void true_value(OPERATORS_NOT_ALLOWED*) {} - }; - typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*); +#include #endif - -} // namespace detail - -} // namespace boost - -#define BOOST_EXPLICIT_OPERATOR_BOOL()\ - BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\ - {\ - return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ - } - -#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ - BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const\ - {\ - return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ - } - -#else // !defined(BOOST_NO_UNSPECIFIED_BOOL) - -#define BOOST_EXPLICIT_OPERATOR_BOOL()\ - BOOST_FORCEINLINE operator bool () const\ - {\ - return !this->operator! ();\ - } - -#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ - BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const\ - {\ - return !this->operator! ();\ - } - -#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL) - -#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - -#endif // BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP_INCLUDED_ diff --git a/src/thirdparty/boost_lib/boost/utility/in_place_factory.hpp b/src/thirdparty/boost_lib/boost/utility/in_place_factory.hpp index f84b003c7..1a62ace10 100644 --- a/src/thirdparty/boost_lib/boost/utility/in_place_factory.hpp +++ b/src/thirdparty/boost_lib/boost/utility/in_place_factory.hpp @@ -48,15 +48,13 @@ class BOOST_PP_CAT(in_place_factory,N) {} template - void* apply(void* address - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const + void* apply(void* address) const { return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) ); } template - void* apply(void* address, std::size_t n - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const + void* apply(void* address, std::size_t n) const { for(char* next = address = this->BOOST_NESTED_TEMPLATE apply(address); !! --n;) diff --git a/src/thirdparty/boost_lib/boost/utility/result_of.hpp b/src/thirdparty/boost_lib/boost/utility/result_of.hpp index a530c3ac2..206ae3088 100644 --- a/src/thirdparty/boost_lib/boost/utility/result_of.hpp +++ b/src/thirdparty/boost_lib/boost/utility/result_of.hpp @@ -68,12 +68,15 @@ namespace boost { template struct result_of; template struct tr1_result_of; // a TR1-style implementation of result_of -#if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +#if !defined(BOOST_NO_SFINAE) namespace detail { BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type) +// Work around a nvcc bug by only defining has_result when it's needed. +#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result) +#endif template struct tr1_result_of_impl; diff --git a/src/thirdparty/boost_lib/boost/utility/swap.hpp b/src/thirdparty/boost_lib/boost/utility/swap.hpp index 6845e7965..dd9ecd907 100644 --- a/src/thirdparty/boost_lib/boost/utility/swap.hpp +++ b/src/thirdparty/boost_lib/boost/utility/swap.hpp @@ -1,55 +1,17 @@ -// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker -// -// 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) -// For more information, see http://www.boost.org - +/* + * Copyright (c) 2014 Glen Fernandes + * + * Distributed under the Boost Software License, Version 1.0. (See + * accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ #ifndef BOOST_UTILITY_SWAP_HPP #define BOOST_UTILITY_SWAP_HPP -// Note: the implementation of this utility contains various workarounds: -// - swap_impl is put outside the boost namespace, to avoid infinite -// recursion (causing stack overflow) when swapping objects of a primitive -// type. -// - swap_impl has a using-directive, rather than a using-declaration, -// because some compilers (including MSVC 7.1, Borland 5.9.3, and -// Intel 8.1) don't do argument-dependent lookup when it has a -// using-declaration instead. -// - boost::swap has two template arguments, instead of one, to -// avoid ambiguity when swapping objects of a Boost type that does -// not have its own boost::swap overload. - -#include //for std::swap -#include //for std::size_t - -namespace boost_swap_impl -{ - template - void swap_impl(T& left, T& right) - { - using namespace std;//use std::swap if argument dependent lookup fails - swap(left,right); - } - - template - void swap_impl(T (& left)[N], T (& right)[N]) - { - for (std::size_t i = 0; i < N; ++i) - { - ::boost_swap_impl::swap_impl(left[i], right[i]); - } - } -} +// The header file at this path is deprecated; +// use boost/core/swap.hpp instead. -namespace boost -{ - template - void swap(T1& left, T2& right) - { - ::boost_swap_impl::swap_impl(left, right); - } -} +#include #endif diff --git a/src/thirdparty/boost_lib/boost/utility/value_init.hpp b/src/thirdparty/boost_lib/boost/utility/value_init.hpp index 5de958575..9d8de7073 100644 --- a/src/thirdparty/boost_lib/boost/utility/value_init.hpp +++ b/src/thirdparty/boost_lib/boost/utility/value_init.hpp @@ -33,7 +33,6 @@ #ifdef BOOST_MSVC #pragma warning(push) -#if _MSC_VER >= 1310 // It is safe to ignore the following warning from MSVC 7.1 or higher: // "warning C4351: new behavior: elements of array will be default initialized" #pragma warning(disable: 4351) @@ -41,7 +40,6 @@ // a const type: "warning C4512: assignment operator could not be generated". #pragma warning(disable: 4512) #endif -#endif #ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED @@ -73,12 +71,14 @@ class initialized #endif remove_const::type data; + BOOST_GPU_ENABLED wrapper() : data() { } + BOOST_GPU_ENABLED wrapper(T const & arg) : data(arg) @@ -92,6 +92,7 @@ class initialized #endif aligned_storage::value>::type x; + BOOST_GPU_ENABLED wrapper * wrapper_address() const { return static_cast( static_cast(&x)); @@ -99,6 +100,7 @@ class initialized public : + BOOST_GPU_ENABLED initialized() { #if BOOST_DETAIL_VALUE_INIT_WORKAROUND @@ -107,16 +109,19 @@ class initialized new (wrapper_address()) wrapper(); } + BOOST_GPU_ENABLED initialized(initialized const & arg) { new (wrapper_address()) wrapper( static_cast(*(arg.wrapper_address()))); } + BOOST_GPU_ENABLED explicit initialized(T const & arg) { new (wrapper_address()) wrapper(arg); } + BOOST_GPU_ENABLED initialized & operator=(initialized const & arg) { // Assignment is only allowed when T is non-const. @@ -125,31 +130,37 @@ class initialized return *this; } + BOOST_GPU_ENABLED ~initialized() { wrapper_address()->wrapper::~wrapper(); } + BOOST_GPU_ENABLED T const & data() const { return wrapper_address()->data; } + BOOST_GPU_ENABLED T& data() { return wrapper_address()->data; } + BOOST_GPU_ENABLED void swap(initialized & arg) { ::boost::swap( this->data(), arg.data() ); } + BOOST_GPU_ENABLED operator T const &() const { return wrapper_address()->data; } + BOOST_GPU_ENABLED operator T&() { return wrapper_address()->data; @@ -158,18 +169,21 @@ class initialized } ; template +BOOST_GPU_ENABLED T const& get ( initialized const& x ) { return x.data() ; } template +BOOST_GPU_ENABLED T& get ( initialized& x ) { return x.data() ; } template +BOOST_GPU_ENABLED void swap ( initialized & lhs, initialized & rhs ) { lhs.swap(rhs) ; @@ -185,31 +199,37 @@ class value_initialized public : + BOOST_GPU_ENABLED value_initialized() : m_data() { } + BOOST_GPU_ENABLED T const & data() const { return m_data.data(); } + BOOST_GPU_ENABLED T& data() { return m_data.data(); } + BOOST_GPU_ENABLED void swap(value_initialized & arg) { m_data.swap(arg.m_data); } + BOOST_GPU_ENABLED operator T const &() const { return m_data; } + BOOST_GPU_ENABLED operator T&() { return m_data; @@ -218,18 +238,21 @@ class value_initialized template +BOOST_GPU_ENABLED T const& get ( value_initialized const& x ) { return x.data() ; } template +BOOST_GPU_ENABLED T& get ( value_initialized& x ) { return x.data() ; } template +BOOST_GPU_ENABLED void swap ( value_initialized & lhs, value_initialized & rhs ) { lhs.swap(rhs) ; @@ -240,7 +263,7 @@ class initialized_value_t { public : - template operator T() const + template BOOST_GPU_ENABLED operator T() const { return initialized().data(); } diff --git a/src/thirdparty/boost_lib/boost/version.hpp b/src/thirdparty/boost_lib/boost/version.hpp index 0df7b2767..fc4c96979 100644 --- a/src/thirdparty/boost_lib/boost/version.hpp +++ b/src/thirdparty/boost_lib/boost/version.hpp @@ -19,7 +19,7 @@ // BOOST_VERSION / 100 % 1000 is the minor version // BOOST_VERSION / 100000 is the major version -#define BOOST_VERSION 105500 +#define BOOST_VERSION 105600 // // BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION @@ -27,6 +27,6 @@ // number, y is the minor version number, and z is the patch level if not 0. // This is used by to select which library version to link to. -#define BOOST_LIB_VERSION "1_55" +#define BOOST_LIB_VERSION "1_56" #endif diff --git a/src/thirdparty/boost_lib/boost/visit_each.hpp b/src/thirdparty/boost_lib/boost/visit_each.hpp index 1fc8a5008..6463ca9c2 100644 --- a/src/thirdparty/boost_lib/boost/visit_each.hpp +++ b/src/thirdparty/boost_lib/boost/visit_each.hpp @@ -10,8 +10,6 @@ #ifndef BOOST_VISIT_EACH_HPP #define BOOST_VISIT_EACH_HPP -#include - namespace boost { template inline void visit_each(Visitor& visitor, const T& t, long)