]>
Commit | Line | Data |
---|---|---|
1e59de90 TL |
1 | /* |
2 | Copyright 2021 Glen Joseph Fernandes | |
3 | (glenjofe@gmail.com) | |
4 | ||
5 | Distributed under the Boost Software License, Version 1.0. | |
6 | (http://www.boost.org/LICENSE_1_0.txt) | |
7 | */ | |
8 | #include <boost/config.hpp> | |
9 | #if (!defined(BOOST_LIBSTDCXX_VERSION) || \ | |
10 | BOOST_LIBSTDCXX_VERSION >= 46000) && \ | |
11 | !defined(BOOST_NO_CXX11_SMART_PTR) | |
12 | #include <boost/smart_ptr/allocate_unique.hpp> | |
13 | #include <boost/core/lightweight_test.hpp> | |
14 | ||
15 | template<class T> | |
16 | class point { | |
17 | public: | |
18 | point() | |
19 | : state_() | |
20 | , ptr_() { } | |
21 | ||
22 | point(int count, T* value) | |
23 | : state_(count) | |
24 | , ptr_(value) { } | |
25 | ||
26 | operator bool() const { | |
27 | return static_cast<bool>(ptr_); | |
28 | } | |
29 | ||
30 | T* operator->() const { | |
31 | return ptr_; | |
32 | } | |
33 | ||
34 | int state() const { | |
35 | return state_; | |
36 | } | |
37 | ||
38 | private: | |
39 | int state_; | |
40 | T* ptr_; | |
41 | }; | |
42 | ||
43 | template<class T = void> | |
44 | class creator { | |
45 | public: | |
46 | typedef T value_type; | |
47 | typedef point<T> pointer; | |
48 | typedef std::ptrdiff_t difference_type; | |
49 | ||
50 | creator() | |
51 | : state_() { } | |
52 | ||
53 | explicit creator(int value) | |
54 | : state_(value) { } | |
55 | ||
56 | template<class U> | |
57 | creator(const creator<U>& other) | |
58 | : state_(other.state()) { } | |
59 | ||
60 | pointer allocate(std::size_t size) { | |
61 | return pointer(state_, | |
62 | static_cast<T*>(::operator new(sizeof(T) * size))); | |
63 | } | |
64 | ||
65 | void deallocate(pointer ptr, std::size_t) { | |
66 | ::operator delete(ptr.operator->()); | |
67 | } | |
68 | ||
69 | int state() const { | |
70 | return state_; | |
71 | } | |
72 | ||
73 | private: | |
74 | int state_; | |
75 | }; | |
76 | ||
77 | template<class T, class U> | |
78 | inline bool | |
79 | operator==(const creator<T>&, const creator<U>&) | |
80 | { | |
81 | return true; | |
82 | } | |
83 | ||
84 | template<class T, class U> | |
85 | inline bool | |
86 | operator!=(const creator<T>&, const creator<U>&) | |
87 | { | |
88 | return false; | |
89 | } | |
90 | ||
91 | int main() | |
92 | { | |
93 | { | |
94 | std::unique_ptr<int, | |
95 | boost::alloc_deleter<int, creator<> > > result = | |
96 | boost::allocate_unique<int>(creator<>(1)); | |
97 | point<int> ptr = boost::get_allocator_pointer(result); | |
98 | BOOST_TEST_EQ(ptr.state(), 1); | |
99 | } | |
100 | { | |
101 | std::unique_ptr<const int, | |
102 | boost::alloc_deleter<const int, creator<> > > result = | |
103 | boost::allocate_unique<const int>(creator<>(2)); | |
104 | point<int> ptr = boost::get_allocator_pointer(result); | |
105 | BOOST_TEST_EQ(ptr.state(), 2); | |
106 | } | |
107 | { | |
108 | std::unique_ptr<int[], | |
109 | boost::alloc_deleter<int[], creator<> > > result = | |
110 | boost::allocate_unique<int[]>(creator<>(3), 3); | |
111 | point<int> ptr = boost::get_allocator_pointer(result); | |
112 | BOOST_TEST_EQ(ptr.state(), 3); | |
113 | } | |
114 | { | |
115 | std::unique_ptr<int[], | |
116 | boost::alloc_deleter<int[3], creator<> > > result = | |
117 | boost::allocate_unique<int[3]>(creator<>(4)); | |
118 | point<int> ptr = boost::get_allocator_pointer(result); | |
119 | BOOST_TEST_EQ(ptr.state(), 4); | |
120 | } | |
121 | { | |
122 | std::unique_ptr<int[][2], | |
123 | boost::alloc_deleter<int[][2], creator<> > > result = | |
124 | boost::allocate_unique<int[][2]>(creator<>(5), 2); | |
125 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
126 | BOOST_TEST_EQ(ptr.state(), 5); | |
127 | } | |
128 | { | |
129 | std::unique_ptr<int[][2], | |
130 | boost::alloc_deleter<int[2][2], creator<> > > result = | |
131 | boost::allocate_unique<int[2][2]>(creator<>(6)); | |
132 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
133 | BOOST_TEST_EQ(ptr.state(), 6); | |
134 | } | |
135 | { | |
136 | std::unique_ptr<const int[], | |
137 | boost::alloc_deleter<const int[], creator<> > > result = | |
138 | boost::allocate_unique<const int[]>(creator<>(7), 3); | |
139 | point<int> ptr = boost::get_allocator_pointer(result); | |
140 | BOOST_TEST_EQ(ptr.state(), 7); | |
141 | } | |
142 | { | |
143 | std::unique_ptr<const int[], | |
144 | boost::alloc_deleter<const int[3], creator<> > > result = | |
145 | boost::allocate_unique<const int[3]>(creator<>(8)); | |
146 | point<int> ptr = boost::get_allocator_pointer(result); | |
147 | BOOST_TEST_EQ(ptr.state(), 8); | |
148 | } | |
149 | { | |
150 | std::unique_ptr<const int[][2], | |
151 | boost::alloc_deleter<const int[][2], creator<> > > result = | |
152 | boost::allocate_unique<const int[][2]>(creator<>(9), 2); | |
153 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
154 | BOOST_TEST_EQ(ptr.state(), 9); | |
155 | } | |
156 | { | |
157 | std::unique_ptr<const int[][2], | |
158 | boost::alloc_deleter<const int[2][2], creator<> > > result = | |
159 | boost::allocate_unique<const int[2][2]>(creator<>(10)); | |
160 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
161 | BOOST_TEST_EQ(ptr.state(), 10); | |
162 | } | |
163 | { | |
164 | std::unique_ptr<int, | |
165 | boost::alloc_deleter<int, | |
166 | boost::noinit_adaptor<creator<> > > > result = | |
167 | boost::allocate_unique_noinit<int>(creator<>(11)); | |
168 | point<int> ptr = boost::get_allocator_pointer(result); | |
169 | BOOST_TEST_EQ(ptr.state(), 11); | |
170 | } | |
171 | { | |
172 | std::unique_ptr<const int, | |
173 | boost::alloc_deleter<const int, | |
174 | boost::noinit_adaptor<creator<> > > > result = | |
175 | boost::allocate_unique_noinit<const int>(creator<>(12)); | |
176 | point<int> ptr = boost::get_allocator_pointer(result); | |
177 | BOOST_TEST_EQ(ptr.state(), 12); | |
178 | } | |
179 | { | |
180 | std::unique_ptr<int[], | |
181 | boost::alloc_deleter<int[], | |
182 | boost::noinit_adaptor<creator<> > > > result = | |
183 | boost::allocate_unique_noinit<int[]>(creator<>(13), 3); | |
184 | point<int> ptr = boost::get_allocator_pointer(result); | |
185 | BOOST_TEST_EQ(ptr.state(), 13); | |
186 | } | |
187 | { | |
188 | std::unique_ptr<int[], | |
189 | boost::alloc_deleter<int[3], | |
190 | boost::noinit_adaptor<creator<> > > > result = | |
191 | boost::allocate_unique_noinit<int[3]>(creator<>(14)); | |
192 | point<int> ptr = boost::get_allocator_pointer(result); | |
193 | BOOST_TEST_EQ(ptr.state(), 14); | |
194 | } | |
195 | { | |
196 | std::unique_ptr<int[][2], | |
197 | boost::alloc_deleter<int[][2], | |
198 | boost::noinit_adaptor<creator<> > > > result = | |
199 | boost::allocate_unique_noinit<int[][2]>(creator<>(15), 2); | |
200 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
201 | BOOST_TEST_EQ(ptr.state(), 15); | |
202 | } | |
203 | { | |
204 | std::unique_ptr<int[][2], | |
205 | boost::alloc_deleter<int[2][2], | |
206 | boost::noinit_adaptor<creator<> > > > result = | |
207 | boost::allocate_unique_noinit<int[2][2]>(creator<>(16)); | |
208 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
209 | BOOST_TEST_EQ(ptr.state(), 16); | |
210 | } | |
211 | { | |
212 | std::unique_ptr<const int[], | |
213 | boost::alloc_deleter<const int[], | |
214 | boost::noinit_adaptor<creator<> > > > result = | |
215 | boost::allocate_unique_noinit<const int[]>(creator<>(17), 3); | |
216 | point<int> ptr = boost::get_allocator_pointer(result); | |
217 | BOOST_TEST_EQ(ptr.state(), 17); | |
218 | } | |
219 | { | |
220 | std::unique_ptr<const int[], | |
221 | boost::alloc_deleter<const int[3], | |
222 | boost::noinit_adaptor<creator<> > > > result = | |
223 | boost::allocate_unique_noinit<const int[3]>(creator<>(18)); | |
224 | point<int> ptr = boost::get_allocator_pointer(result); | |
225 | BOOST_TEST_EQ(ptr.state(), 18); | |
226 | } | |
227 | { | |
228 | std::unique_ptr<const int[][2], | |
229 | boost::alloc_deleter<const int[][2], | |
230 | boost::noinit_adaptor<creator<> > > > result = | |
231 | boost::allocate_unique_noinit<const int[][2]>(creator<>(19), 2); | |
232 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
233 | BOOST_TEST_EQ(ptr.state(), 19); | |
234 | } | |
235 | { | |
236 | std::unique_ptr<const int[][2], | |
237 | boost::alloc_deleter<const int[2][2], | |
238 | boost::noinit_adaptor<creator<> > > > result = | |
239 | boost::allocate_unique_noinit<const int[2][2]>(creator<>(20)); | |
240 | point<int[2]> ptr = boost::get_allocator_pointer(result); | |
241 | BOOST_TEST_EQ(ptr.state(), 20); | |
242 | } | |
243 | return boost::report_errors(); | |
244 | } | |
245 | #else | |
246 | int main() | |
247 | { | |
248 | return 0; | |
249 | } | |
250 | #endif |