← Back to branch summary

~ubuntu-branches/ubuntu/wily/ruby-passenger/wily-proposed

« back to all changes in this revision

Viewing changes to ext/boost/smart_ptr/allocate_shared_array.hpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-11-23 23:50:02 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20131123235002-8fdhsq7afj15o2z2
Tags: 4.0.25-1
http://bugs.debian.org/725591
* New upstream release.
* Refresh fix_install_path.patch.
* Build for Ruby 2.0 instead of 1.8. (Closes: #725591)
* Add fix_ftbfs_fortify_source.patch.
* Install passenger template files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/boost/smart_ptr/allocate_shared_array.hpp
 
1
/*
 
2
 * Copyright (c) 2012 Glen Joseph Fernandes
 
3
 * glenfe at live dot com
 
4
 *
 
5
 * Distributed under the Boost Software License,
 
6
 * Version 1.0. (See accompanying file LICENSE_1_0.txt
 
7
 * or copy at http://boost.org/LICENSE_1_0.txt)
 
8
 */
 
9
#ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
 
10
#define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
 
11
 
 
12
#include <boost/smart_ptr/shared_ptr.hpp>
 
13
#include <boost/smart_ptr/detail/allocate_array_helper.hpp>
 
14
#include <boost/smart_ptr/detail/array_deleter.hpp>
 
15
#include <boost/smart_ptr/detail/array_traits.hpp>
 
16
#include <boost/smart_ptr/detail/sp_if_array.hpp>
 
17
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
18
#include <initializer_list>
 
19
#endif
 
20
 
 
21
namespace boost {
 
22
    template<typename T, typename A>
 
23
    inline typename boost::detail::sp_if_array<T>::type
 
24
    allocate_shared(const A& allocator, std::size_t size) {
 
25
        typedef typename boost::detail::array_inner<T>::type T1;
 
26
        typedef typename boost::detail::array_base<T1>::type T2;
 
27
        T1* p1 = 0;
 
28
        T2* p2 = 0;
 
29
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
 
30
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
 
31
        boost::detail::array_deleter<T2[]> d1(n1);
 
32
        boost::shared_ptr<T> s1(p1, d1, a1);
 
33
        typedef boost::detail::array_deleter<T2[]>* D2;
 
34
        p1 = reinterpret_cast<T1*>(p2);
 
35
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
36
        d2->init(p2);
 
37
        return boost::shared_ptr<T>(s1, p1);
 
38
    }
 
39
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
40
    template<typename T, typename A, typename... Args>
 
41
    inline typename boost::detail::sp_if_array<T>::type
 
42
    allocate_shared(const A& allocator, std::size_t size, Args&&... args) {
 
43
        typedef typename boost::detail::array_inner<T>::type T1;
 
44
        typedef typename boost::detail::array_base<T1>::type T2;
 
45
        T1* p1 = 0;
 
46
        T2* p2 = 0;
 
47
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
 
48
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
 
49
        boost::detail::array_deleter<T2[]> d1(n1);
 
50
        boost::shared_ptr<T> s1(p1, d1, a1);
 
51
        typedef boost::detail::array_deleter<T2[]>* D2;
 
52
        p1 = reinterpret_cast<T1*>(p2);
 
53
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
54
        d2->init(p2, boost::detail::sp_forward<Args>(args)...);
 
55
        return boost::shared_ptr<T>(s1, p1);
 
56
    }
 
57
    template<typename T, typename A, typename... Args>
 
58
    inline typename boost::detail::sp_if_size_array<T>::type
 
59
    allocate_shared(const A& allocator, Args&&... args) {
 
60
        typedef typename boost::detail::array_inner<T>::type T1;
 
61
        typedef typename boost::detail::array_base<T1>::type T2;
 
62
        enum {
 
63
            N = boost::detail::array_total<T>::size
 
64
        };
 
65
        T1* p1 = 0;
 
66
        T2* p2 = 0;
 
67
        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
 
68
        boost::detail::array_deleter<T2[N]> d1;
 
69
        boost::shared_ptr<T> s1(p1, d1, a1);
 
70
        typedef boost::detail::array_deleter<T2[N]>* D2;
 
71
        p1 = reinterpret_cast<T1*>(p2);
 
72
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
73
        d2->init(p2, boost::detail::sp_forward<Args>(args)...);
 
74
        return boost::shared_ptr<T>(s1, p1);
 
75
    }
 
76
#endif
 
77
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
 
78
    template<typename T, typename A>
 
79
    inline typename boost::detail::sp_if_size_array<T>::type
 
80
    allocate_shared(const A& allocator, const T& list) {
 
81
        typedef typename boost::detail::array_inner<T>::type T1;
 
82
        typedef typename boost::detail::array_base<T1>::type T2;
 
83
        typedef const T2 T3;
 
84
        enum {
 
85
            N = boost::detail::array_total<T>::size
 
86
        };
 
87
        T1* p1 = 0;
 
88
        T2* p2 = 0;
 
89
        T3* p3 = 0;
 
90
        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
 
91
        boost::detail::array_deleter<T2[N]> d1;
 
92
        boost::shared_ptr<T> s1(p1, d1, a1);
 
93
        typedef boost::detail::array_deleter<T2[N]>* D2;
 
94
        p3 = reinterpret_cast<T3*>(list);
 
95
        p1 = reinterpret_cast<T1*>(p2);
 
96
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
97
        d2->init_list(p2, p3);
 
98
        return boost::shared_ptr<T>(s1, p1);
 
99
    }
 
100
    template<typename T, typename A>
 
101
    inline typename boost::detail::sp_if_array<T>::type
 
102
    allocate_shared(const A& allocator, std::size_t size,
 
103
        const typename boost::detail::array_inner<T>::type& list) {
 
104
        typedef typename boost::detail::array_inner<T>::type T1;
 
105
        typedef typename boost::detail::array_base<T1>::type T2;
 
106
        typedef const T2 T3;
 
107
        enum {
 
108
            M = boost::detail::array_total<T1>::size
 
109
        };
 
110
        T1* p1 = 0;
 
111
        T2* p2 = 0;
 
112
        T3* p3 = 0;
 
113
        std::size_t n1 = M * size;
 
114
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
 
115
        boost::detail::array_deleter<T2[]> d1(n1);
 
116
        boost::shared_ptr<T> s1(p1, d1, a1);
 
117
        typedef boost::detail::array_deleter<T2[]>* D2;
 
118
        p3 = reinterpret_cast<T3*>(list);
 
119
        p1 = reinterpret_cast<T1*>(p2);
 
120
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
121
        d2->template init_list<M>(p2, p3);
 
122
        return boost::shared_ptr<T>(s1, p1);
 
123
    }
 
124
    template<typename T, typename A>
 
125
    inline typename boost::detail::sp_if_size_array<T>::type
 
126
    allocate_shared(const A& allocator,
 
127
        const typename boost::detail::array_inner<T>::type& list) {
 
128
        typedef typename boost::detail::array_inner<T>::type T1;
 
129
        typedef typename boost::detail::array_base<T1>::type T2;
 
130
        typedef const T2 T3;
 
131
        enum {
 
132
            M = boost::detail::array_total<T1>::size,
 
133
            N = boost::detail::array_total<T>::size
 
134
        };
 
135
        T1* p1 = 0;
 
136
        T2* p2 = 0;
 
137
        T3* p3 = 0;
 
138
        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
 
139
        boost::detail::array_deleter<T2[N]> d1;
 
140
        boost::shared_ptr<T> s1(p1, d1, a1);
 
141
        typedef boost::detail::array_deleter<T2[N]>* D2;
 
142
        p3 = reinterpret_cast<T3*>(list);
 
143
        p1 = reinterpret_cast<T1*>(p2);
 
144
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
145
        d2->template init_list<M>(p2, p3);
 
146
        return boost::shared_ptr<T>(s1, p1);
 
147
    }
 
148
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
149
    template<typename T, typename A>
 
150
    inline typename boost::detail::sp_if_array<T>::type
 
151
    allocate_shared(const A& allocator,
 
152
        std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
 
153
        typedef typename boost::detail::array_inner<T>::type T1;
 
154
        typedef typename boost::detail::array_base<T1>::type T2;
 
155
        typedef const T2 T3;
 
156
        T1* p1 = 0;
 
157
        T2* p2 = 0;
 
158
        T3* p3 = 0;
 
159
        std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
 
160
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
 
161
        boost::detail::array_deleter<T2[]> d1(n1);
 
162
        boost::shared_ptr<T> s1(p1, d1, a1);
 
163
        typedef boost::detail::array_deleter<T2[]>* D2;
 
164
        p3 = reinterpret_cast<T3*>(list.begin());
 
165
        p1 = reinterpret_cast<T1*>(p2);
 
166
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
167
        d2->init_list(p2, p3);
 
168
        return boost::shared_ptr<T>(s1, p1);
 
169
    }
 
170
#endif
 
171
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
172
    template<typename T, typename A>
 
173
    inline typename boost::detail::sp_if_array<T>::type
 
174
    allocate_shared(const A& allocator, std::size_t size,
 
175
        typename boost::detail::array_base<T>::type&& value) {
 
176
        typedef typename boost::detail::array_inner<T>::type T1;
 
177
        typedef typename boost::detail::array_base<T1>::type T2;
 
178
        T1* p1 = 0;
 
179
        T2* p2 = 0;
 
180
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
 
181
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
 
182
        boost::detail::array_deleter<T2[]> d1(n1);
 
183
        boost::shared_ptr<T> s1(p1, d1, a1);
 
184
        typedef boost::detail::array_deleter<T2[]>* D2;
 
185
        p1 = reinterpret_cast<T1*>(p2);
 
186
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
187
        d2->init(p2, boost::detail::sp_forward<T2>(value));
 
188
        return boost::shared_ptr<T>(s1, p1);
 
189
    }
 
190
    template<typename T, typename A>
 
191
    inline typename boost::detail::sp_if_size_array<T>::type
 
192
    allocate_shared(const A& allocator,
 
193
        typename boost::detail::array_base<T>::type&& value) {
 
194
        typedef typename boost::detail::array_inner<T>::type T1;
 
195
        typedef typename boost::detail::array_base<T1>::type T2;
 
196
        enum {
 
197
            N = boost::detail::array_total<T>::size
 
198
        };
 
199
        T1* p1 = 0;
 
200
        T2* p2 = 0;
 
201
        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
 
202
        boost::detail::array_deleter<T2[N]> d1;
 
203
        boost::shared_ptr<T> s1(p1, d1, a1);
 
204
        typedef boost::detail::array_deleter<T2[N]>* D2;
 
205
        p1 = reinterpret_cast<T1*>(p2);
 
206
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
207
        d2->init(p2, boost::detail::sp_forward<T2>(value));
 
208
        return boost::shared_ptr<T>(s1, p1);
 
209
    }
 
210
#endif
 
211
#endif
 
212
    template<typename T, typename A>
 
213
    inline typename boost::detail::sp_if_array<T>::type
 
214
    allocate_shared_noinit(const A& allocator, std::size_t size) {
 
215
        typedef typename boost::detail::array_inner<T>::type T1;
 
216
        typedef typename boost::detail::array_base<T1>::type T2;
 
217
        T1* p1 = 0;
 
218
        T2* p2 = 0;
 
219
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
 
220
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
 
221
        boost::detail::array_deleter<T2[]> d1(n1);
 
222
        boost::shared_ptr<T> s1(p1, d1, a1);
 
223
        typedef boost::detail::array_deleter<T2[]>* D2;
 
224
        p1 = reinterpret_cast<T1*>(p2);
 
225
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
226
        d2->noinit(p2);
 
227
        return boost::shared_ptr<T>(s1, p1);
 
228
    }
 
229
    template<typename T, typename A>
 
230
    inline typename boost::detail::sp_if_size_array<T>::type
 
231
    allocate_shared_noinit(const A& allocator) {
 
232
        typedef typename boost::detail::array_inner<T>::type T1;
 
233
        typedef typename boost::detail::array_base<T1>::type T2;
 
234
        enum {
 
235
            N = boost::detail::array_total<T>::size
 
236
        };
 
237
        T1* p1 = 0;
 
238
        T2* p2 = 0;
 
239
        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
 
240
        boost::detail::array_deleter<T2[N]> d1;
 
241
        boost::shared_ptr<T> s1(p1, d1, a1);
 
242
        typedef boost::detail::array_deleter<T2[N]>* D2;
 
243
        p1 = reinterpret_cast<T1*>(p2);
 
244
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
 
245
        d2->noinit(p2);
 
246
        return boost::shared_ptr<T>(s1, p1);
 
247
    }
 
248
}
 
249
 
 
250
#endif