passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/array_allocator.hpp

@@ -1,318 +0,0 @@
-/*
- * 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 <boost/align/align.hpp>
-#include <boost/smart_ptr/detail/array_traits.hpp>
-#include <boost/smart_ptr/detail/array_utility.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-namespace boost {
-    namespace detail {
-        struct ms_init_tag   { };
-        struct ms_noinit_tag { };
-
-        template<class T>
-        struct ms_allocator_state;
-
-        template<class T>
-        struct ms_allocator_state<T[]> {
-            typedef typename array_base<T>::type type;
-
-            ms_allocator_state(std::size_t size_,
-                type** result_)
-                : size(size_ * array_total<T>::size),
-                  result(result_) {
-            }
-
-            std::size_t size;
-
-            union {
-                type** result;
-                type* object;
-            };
-        };
-
-        template<class T, std::size_t N>
-        struct ms_allocator_state<T[N]> {
-            typedef typename array_base<T>::type type;
-
-            ms_allocator_state(type** result_)
-                : result(result_) {
-            }
-
-            enum {
-                size = array_total<T[N]>::size
-            };
-
-            union {
-                type** result;
-                type* object;
-            };
-        };
-
-        template<class A, class T, class R>
-        class as_allocator
-            : public A {
-            template<class A_, class T_, class R_>
-            friend class as_allocator;
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            typedef std::allocator_traits<A> AT;
-            typedef typename AT::template rebind_alloc<char> CA;
-            typedef typename AT::template rebind_traits<char> CT;
-#else
-            typedef typename A::template rebind<char>::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<class U>
-            struct rebind {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                typedef as_allocator<typename AT::
-                    template rebind_alloc<U>, T, R> other;
-#else
-                typedef as_allocator<typename A::
-                    template rebind<U>::other, T, R> other;
-#endif
-            };
-
-            typedef typename array_base<T>::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<class U>
-            as_allocator(const as_allocator<U, T, R>& other)
-                : A(other.allocator()),
-                  data(other.data) {
-            }
-
-            pointer allocate(size_type count, const_void_pointer = 0) {
-                enum {
-                    M = boost::alignment_of<type>::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<char*>(p1) + n1;
-                (void)boost::alignment::align(M, n2, p2, n3);
-                *data.result = static_cast<type*>(p2);
-                return static_cast<value_type*>(p1);
-            }
-
-            void deallocate(pointer memory, size_type count) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(value_type);
-                std::size_t n2 = data.size * sizeof(type) + M;
-                char* p1 = reinterpret_cast<char*>(memory);
-                CA ca(allocator());
-                ca.deallocate(p1, n1 + n2);
-            }
-
-            const A& allocator() const {
-                return static_cast<const A&>(*this);
-            }
-
-            A& allocator() {
-                return static_cast<A&>(*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<T> data;
-        };
-
-        template<class A1, class A2, class T, class R>
-        bool operator==(const as_allocator<A1, T, R>& a1,
-            const as_allocator<A2, T, R>& a2) {
-            return a1.allocator() == a2.allocator();
-        }
-
-        template<class A1, class A2, class T, class R>
-        bool operator!=(const as_allocator<A1, T, R>& a1,
-            const as_allocator<A2, T, R>& a2) {
-            return a1.allocator() != a2.allocator();
-        }
-
-        template<class T, class Y = char>
-        class ms_allocator;
-
-        template<class T, class Y>
-        class ms_allocator {
-            template<class T_, class Y_>
-            friend class ms_allocator;
-
-        public:
-            typedef typename array_base<T>::type type;
-
-            typedef Y value_type;
-            typedef Y* pointer;
-            typedef const Y* const_pointer;
-            typedef std::size_t size_type;
-            typedef std::ptrdiff_t difference_type;
-            typedef Y& reference;
-            typedef const Y& const_reference;
-
-            template<class U>
-            struct rebind {
-                typedef ms_allocator<T, U> other;
-            };
-
-            ms_allocator(type** result)
-                : data(result) {
-            }
-
-            ms_allocator(std::size_t size, type** result)
-                : data(size, result) {
-            }
-
-            template<class U>
-            ms_allocator(const ms_allocator<T, U>& other)
-                : data(other.data) {
-            }
-
-            pointer allocate(size_type count, const void* = 0) {
-                enum {
-                    M = boost::alignment_of<type>::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<char*>(p1) + n1;
-                (void)boost::alignment::align(M, n2, p2, n3);
-                *data.result = static_cast<type*>(p2);
-                return static_cast<Y*>(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<std::size_t>(-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<T> data;
-        };
-
-        template<class T, class Y1, class Y2>
-        bool operator==(const ms_allocator<T, Y1>&,
-            const ms_allocator<T, Y2>&) {
-            return true;
-        }
-
-        template<class T, class Y1, class Y2>
-        bool operator!=(const ms_allocator<T, Y1>&,
-            const ms_allocator<T, Y2>&) {
-            return false;
-        }
-
-        class ms_in_allocator_tag {
-        public:
-            void operator()(const void*) {
-            }
-        };
-    }
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/array_count_impl.hpp

@@ -1,67 +0,0 @@
-/*
- * 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 <boost/smart_ptr/detail/array_allocator.hpp>
-#include <boost/smart_ptr/detail/sp_counted_impl.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class P, class A>
-        class sp_counted_impl_pda<P, ms_in_allocator_tag, A>
-            : public sp_counted_base {
-            typedef ms_in_allocator_tag D;
-            typedef sp_counted_impl_pda<P, D, A> 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<A>::
-                    template rebind_alloc<Y> YA;
-                typedef typename std::allocator_traits<A>::
-                    template rebind_traits<Y> YT;
-#else
-                typedef typename A::template rebind<Y>::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<char&>(allocator);
-            }
-
-            virtual void* get_untyped_deleter() {
-                return &reinterpret_cast<char&>(allocator);
-            }
-
-        private:
-            sp_counted_impl_pda(const sp_counted_impl_pda&);
-            sp_counted_impl_pda& operator=(const sp_counted_impl_pda&);
-
-            A allocator;
-        };
-    }
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/array_traits.hpp

@@ -1,60 +0,0 @@
-/*
- * 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_TRAITS_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
-
-#include <boost/type_traits/remove_cv.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct array_base {
-            typedef typename boost::remove_cv<T>::type type;
-        };
-
-        template<class T>
-        struct array_base<T[]> {
-            typedef typename array_base<T>::type type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_base<T[N]> {
-            typedef typename array_base<T>::type type;
-        };
-
-        template<class T>
-        struct array_total {
-            enum {
-                size = 1
-            };
-        };
-
-        template<class T, std::size_t N>
-        struct array_total<T[N]> {
-            enum {
-                size = N * array_total<T>::size
-            };
-        };
-
-        template<class T>
-        struct array_inner;
-
-        template<class T>
-        struct array_inner<T[]> {
-            typedef T type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_inner<T[N]> {
-            typedef T type;
-        };
-    }
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/array_utility.hpp

@@ -1,214 +0,0 @@
-/*
- * 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_UTILITY_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/has_trivial_constructor.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <memory>
-#endif
-
-namespace boost {
-    namespace detail {
-        typedef boost::true_type  ms_is_trivial;
-        typedef boost::false_type ms_no_trivial;
-
-        template<class T>
-        inline void ms_destroy(T*, std::size_t, ms_is_trivial) {
-        }
-
-        template<class T>
-        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<class T>
-        inline void ms_destroy(T* memory, std::size_t size) {
-            boost::has_trivial_destructor<T> trivial;
-            ms_destroy(memory, size, trivial);
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size, ms_is_trivial) {
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T();
-            }
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size, ms_no_trivial) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T();
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T();
-            }
-#endif
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            ms_init(memory, size, trivial);
-        }
-
-        template<class T, std::size_t N>
-        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(list[i % N]);
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T(list[i % N]);
-            }
-#endif
-        }
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        template<class T, class A>
-        inline void as_destroy(const A& allocator, T* memory,
-            std::size_t size) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-            for (std::size_t i = size; i > 0;) {
-                TT::destroy(a2, &memory[--i]);
-            }
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            ms_is_trivial) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i);
-            }
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            ms_no_trivial) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    TT::construct(a2, memory + i);
-                }
-            } catch (...) {
-                as_destroy(a2, memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i);
-            }
-#endif
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            as_init(allocator, memory, size, trivial);
-        }
-
-        template<class T, class A, std::size_t N>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            const T* list) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    TT::construct(a2, memory + i, list[i % N]);
-                }
-            } catch (...) {
-                as_destroy(a2, memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i, list[i % N]);
-            }
-#endif
-        }
-#endif
-
-        template<class T>
-        inline void ms_noinit(T*, std::size_t, ms_is_trivial) {
-        }
-
-        template<class T>
-        inline void ms_noinit(T* memory, std::size_t size, ms_no_trivial) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T;
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T;
-            }
-#endif
-        }
-
-        template<class T>
-        inline void ms_noinit(T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            ms_noinit(memory, size, trivial);
-        }
-    }
-}
-
-#endif