1// Copyright (C) 2000 Stephen Cleary
2//
3// Distributed under the Boost Software License, Version 1.0. (See accompany-
4// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5//
6// See http://www.boost.org for updates, documentation, and revision history.
7
8// This file was AUTOMATICALLY GENERATED from "stdin"
9// Do NOT include directly!
10// Do NOT edit!
11
12template <typename T0>
13element_type * construct(T0 & a0)
14{
15 element_type * const ret = (malloc)();
16 if (ret == 0)
17 return ret;
18 try { new (ret) element_type(a0); }
19 catch (...) { (free)(chunk: ret); throw; }
20 return ret;
21}
22template <typename T0>
23element_type * construct(const T0 & a0)
24{
25 element_type * const ret = (malloc)();
26 if (ret == 0)
27 return ret;
28 try { new (ret) element_type(a0); }
29 catch (...) { (free)(chunk: ret); throw; }
30 return ret;
31}
32template <typename T0>
33element_type * construct(volatile T0 & a0)
34{
35 element_type * const ret = (malloc)();
36 if (ret == 0)
37 return ret;
38 try { new (ret) element_type(a0); }
39 catch (...) { (free)(chunk: ret); throw; }
40 return ret;
41}
42template <typename T0>
43element_type * construct(const volatile T0 & a0)
44{
45 element_type * const ret = (malloc)();
46 if (ret == 0)
47 return ret;
48 try { new (ret) element_type(a0); }
49 catch (...) { (free)(chunk: ret); throw; }
50 return ret;
51}
52template <typename T0, typename T1>
53element_type * construct(T0 & a0, T1 & a1)
54{
55 element_type * const ret = (malloc)();
56 if (ret == 0)
57 return ret;
58 try { new (ret) element_type(a0, a1); }
59 catch (...) { (free)(chunk: ret); throw; }
60 return ret;
61}
62template <typename T0, typename T1>
63element_type * construct(const T0 & a0, T1 & a1)
64{
65 element_type * const ret = (malloc)();
66 if (ret == 0)
67 return ret;
68 try { new (ret) element_type(a0, a1); }
69 catch (...) { (free)(chunk: ret); throw; }
70 return ret;
71}
72template <typename T0, typename T1>
73element_type * construct(volatile T0 & a0, T1 & a1)
74{
75 element_type * const ret = (malloc)();
76 if (ret == 0)
77 return ret;
78 try { new (ret) element_type(a0, a1); }
79 catch (...) { (free)(chunk: ret); throw; }
80 return ret;
81}
82template <typename T0, typename T1>
83element_type * construct(const volatile T0 & a0, T1 & a1)
84{
85 element_type * const ret = (malloc)();
86 if (ret == 0)
87 return ret;
88 try { new (ret) element_type(a0, a1); }
89 catch (...) { (free)(chunk: ret); throw; }
90 return ret;
91}
92template <typename T0, typename T1>
93element_type * construct(T0 & a0, const T1 & a1)
94{
95 element_type * const ret = (malloc)();
96 if (ret == 0)
97 return ret;
98 try { new (ret) element_type(a0, a1); }
99 catch (...) { (free)(chunk: ret); throw; }
100 return ret;
101}
102template <typename T0, typename T1>
103element_type * construct(const T0 & a0, const T1 & a1)
104{
105 element_type * const ret = (malloc)();
106 if (ret == 0)
107 return ret;
108 try { new (ret) element_type(a0, a1); }
109 catch (...) { (free)(chunk: ret); throw; }
110 return ret;
111}
112template <typename T0, typename T1>
113element_type * construct(volatile T0 & a0, const T1 & a1)
114{
115 element_type * const ret = (malloc)();
116 if (ret == 0)
117 return ret;
118 try { new (ret) element_type(a0, a1); }
119 catch (...) { (free)(chunk: ret); throw; }
120 return ret;
121}
122template <typename T0, typename T1>
123element_type * construct(const volatile T0 & a0, const T1 & a1)
124{
125 element_type * const ret = (malloc)();
126 if (ret == 0)
127 return ret;
128 try { new (ret) element_type(a0, a1); }
129 catch (...) { (free)(chunk: ret); throw; }
130 return ret;
131}
132template <typename T0, typename T1>
133element_type * construct(T0 & a0, volatile T1 & a1)
134{
135 element_type * const ret = (malloc)();
136 if (ret == 0)
137 return ret;
138 try { new (ret) element_type(a0, a1); }
139 catch (...) { (free)(chunk: ret); throw; }
140 return ret;
141}
142template <typename T0, typename T1>
143element_type * construct(const T0 & a0, volatile T1 & a1)
144{
145 element_type * const ret = (malloc)();
146 if (ret == 0)
147 return ret;
148 try { new (ret) element_type(a0, a1); }
149 catch (...) { (free)(chunk: ret); throw; }
150 return ret;
151}
152template <typename T0, typename T1>
153element_type * construct(volatile T0 & a0, volatile T1 & a1)
154{
155 element_type * const ret = (malloc)();
156 if (ret == 0)
157 return ret;
158 try { new (ret) element_type(a0, a1); }
159 catch (...) { (free)(chunk: ret); throw; }
160 return ret;
161}
162template <typename T0, typename T1>
163element_type * construct(const volatile T0 & a0, volatile T1 & a1)
164{
165 element_type * const ret = (malloc)();
166 if (ret == 0)
167 return ret;
168 try { new (ret) element_type(a0, a1); }
169 catch (...) { (free)(chunk: ret); throw; }
170 return ret;
171}
172template <typename T0, typename T1>
173element_type * construct(T0 & a0, const volatile T1 & a1)
174{
175 element_type * const ret = (malloc)();
176 if (ret == 0)
177 return ret;
178 try { new (ret) element_type(a0, a1); }
179 catch (...) { (free)(chunk: ret); throw; }
180 return ret;
181}
182template <typename T0, typename T1>
183element_type * construct(const T0 & a0, const volatile T1 & a1)
184{
185 element_type * const ret = (malloc)();
186 if (ret == 0)
187 return ret;
188 try { new (ret) element_type(a0, a1); }
189 catch (...) { (free)(chunk: ret); throw; }
190 return ret;
191}
192template <typename T0, typename T1>
193element_type * construct(volatile T0 & a0, const volatile T1 & a1)
194{
195 element_type * const ret = (malloc)();
196 if (ret == 0)
197 return ret;
198 try { new (ret) element_type(a0, a1); }
199 catch (...) { (free)(chunk: ret); throw; }
200 return ret;
201}
202template <typename T0, typename T1>
203element_type * construct(const volatile T0 & a0, const volatile T1 & a1)
204{
205 element_type * const ret = (malloc)();
206 if (ret == 0)
207 return ret;
208 try { new (ret) element_type(a0, a1); }
209 catch (...) { (free)(chunk: ret); throw; }
210 return ret;
211}
212template <typename T0, typename T1, typename T2>
213element_type * construct(T0 & a0, T1 & a1, T2 & a2)
214{
215 element_type * const ret = (malloc)();
216 if (ret == 0)
217 return ret;
218 try { new (ret) element_type(a0, a1, a2); }
219 catch (...) { (free)(chunk: ret); throw; }
220 return ret;
221}
222template <typename T0, typename T1, typename T2>
223element_type * construct(const T0 & a0, T1 & a1, T2 & a2)
224{
225 element_type * const ret = (malloc)();
226 if (ret == 0)
227 return ret;
228 try { new (ret) element_type(a0, a1, a2); }
229 catch (...) { (free)(chunk: ret); throw; }
230 return ret;
231}
232template <typename T0, typename T1, typename T2>
233element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2)
234{
235 element_type * const ret = (malloc)();
236 if (ret == 0)
237 return ret;
238 try { new (ret) element_type(a0, a1, a2); }
239 catch (...) { (free)(chunk: ret); throw; }
240 return ret;
241}
242template <typename T0, typename T1, typename T2>
243element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2)
244{
245 element_type * const ret = (malloc)();
246 if (ret == 0)
247 return ret;
248 try { new (ret) element_type(a0, a1, a2); }
249 catch (...) { (free)(chunk: ret); throw; }
250 return ret;
251}
252template <typename T0, typename T1, typename T2>
253element_type * construct(T0 & a0, const T1 & a1, T2 & a2)
254{
255 element_type * const ret = (malloc)();
256 if (ret == 0)
257 return ret;
258 try { new (ret) element_type(a0, a1, a2); }
259 catch (...) { (free)(chunk: ret); throw; }
260 return ret;
261}
262template <typename T0, typename T1, typename T2>
263element_type * construct(const T0 & a0, const T1 & a1, T2 & a2)
264{
265 element_type * const ret = (malloc)();
266 if (ret == 0)
267 return ret;
268 try { new (ret) element_type(a0, a1, a2); }
269 catch (...) { (free)(chunk: ret); throw; }
270 return ret;
271}
272template <typename T0, typename T1, typename T2>
273element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2)
274{
275 element_type * const ret = (malloc)();
276 if (ret == 0)
277 return ret;
278 try { new (ret) element_type(a0, a1, a2); }
279 catch (...) { (free)(chunk: ret); throw; }
280 return ret;
281}
282template <typename T0, typename T1, typename T2>
283element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2)
284{
285 element_type * const ret = (malloc)();
286 if (ret == 0)
287 return ret;
288 try { new (ret) element_type(a0, a1, a2); }
289 catch (...) { (free)(chunk: ret); throw; }
290 return ret;
291}
292template <typename T0, typename T1, typename T2>
293element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2)
294{
295 element_type * const ret = (malloc)();
296 if (ret == 0)
297 return ret;
298 try { new (ret) element_type(a0, a1, a2); }
299 catch (...) { (free)(chunk: ret); throw; }
300 return ret;
301}
302template <typename T0, typename T1, typename T2>
303element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2)
304{
305 element_type * const ret = (malloc)();
306 if (ret == 0)
307 return ret;
308 try { new (ret) element_type(a0, a1, a2); }
309 catch (...) { (free)(chunk: ret); throw; }
310 return ret;
311}
312template <typename T0, typename T1, typename T2>
313element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2)
314{
315 element_type * const ret = (malloc)();
316 if (ret == 0)
317 return ret;
318 try { new (ret) element_type(a0, a1, a2); }
319 catch (...) { (free)(chunk: ret); throw; }
320 return ret;
321}
322template <typename T0, typename T1, typename T2>
323element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2)
324{
325 element_type * const ret = (malloc)();
326 if (ret == 0)
327 return ret;
328 try { new (ret) element_type(a0, a1, a2); }
329 catch (...) { (free)(chunk: ret); throw; }
330 return ret;
331}
332template <typename T0, typename T1, typename T2>
333element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2)
334{
335 element_type * const ret = (malloc)();
336 if (ret == 0)
337 return ret;
338 try { new (ret) element_type(a0, a1, a2); }
339 catch (...) { (free)(chunk: ret); throw; }
340 return ret;
341}
342template <typename T0, typename T1, typename T2>
343element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2)
344{
345 element_type * const ret = (malloc)();
346 if (ret == 0)
347 return ret;
348 try { new (ret) element_type(a0, a1, a2); }
349 catch (...) { (free)(chunk: ret); throw; }
350 return ret;
351}
352template <typename T0, typename T1, typename T2>
353element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2)
354{
355 element_type * const ret = (malloc)();
356 if (ret == 0)
357 return ret;
358 try { new (ret) element_type(a0, a1, a2); }
359 catch (...) { (free)(chunk: ret); throw; }
360 return ret;
361}
362template <typename T0, typename T1, typename T2>
363element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2)
364{
365 element_type * const ret = (malloc)();
366 if (ret == 0)
367 return ret;
368 try { new (ret) element_type(a0, a1, a2); }
369 catch (...) { (free)(chunk: ret); throw; }
370 return ret;
371}
372template <typename T0, typename T1, typename T2>
373element_type * construct(T0 & a0, T1 & a1, const T2 & a2)
374{
375 element_type * const ret = (malloc)();
376 if (ret == 0)
377 return ret;
378 try { new (ret) element_type(a0, a1, a2); }
379 catch (...) { (free)(chunk: ret); throw; }
380 return ret;
381}
382template <typename T0, typename T1, typename T2>
383element_type * construct(const T0 & a0, T1 & a1, const T2 & a2)
384{
385 element_type * const ret = (malloc)();
386 if (ret == 0)
387 return ret;
388 try { new (ret) element_type(a0, a1, a2); }
389 catch (...) { (free)(chunk: ret); throw; }
390 return ret;
391}
392template <typename T0, typename T1, typename T2>
393element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2)
394{
395 element_type * const ret = (malloc)();
396 if (ret == 0)
397 return ret;
398 try { new (ret) element_type(a0, a1, a2); }
399 catch (...) { (free)(chunk: ret); throw; }
400 return ret;
401}
402template <typename T0, typename T1, typename T2>
403element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2)
404{
405 element_type * const ret = (malloc)();
406 if (ret == 0)
407 return ret;
408 try { new (ret) element_type(a0, a1, a2); }
409 catch (...) { (free)(chunk: ret); throw; }
410 return ret;
411}
412template <typename T0, typename T1, typename T2>
413element_type * construct(T0 & a0, const T1 & a1, const T2 & a2)
414{
415 element_type * const ret = (malloc)();
416 if (ret == 0)
417 return ret;
418 try { new (ret) element_type(a0, a1, a2); }
419 catch (...) { (free)(chunk: ret); throw; }
420 return ret;
421}
422template <typename T0, typename T1, typename T2>
423element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
424{
425 element_type * const ret = (malloc)();
426 if (ret == 0)
427 return ret;
428 try { new (ret) element_type(a0, a1, a2); }
429 catch (...) { (free)(chunk: ret); throw; }
430 return ret;
431}
432template <typename T0, typename T1, typename T2>
433element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2)
434{
435 element_type * const ret = (malloc)();
436 if (ret == 0)
437 return ret;
438 try { new (ret) element_type(a0, a1, a2); }
439 catch (...) { (free)(chunk: ret); throw; }
440 return ret;
441}
442template <typename T0, typename T1, typename T2>
443element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2)
444{
445 element_type * const ret = (malloc)();
446 if (ret == 0)
447 return ret;
448 try { new (ret) element_type(a0, a1, a2); }
449 catch (...) { (free)(chunk: ret); throw; }
450 return ret;
451}
452template <typename T0, typename T1, typename T2>
453element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2)
454{
455 element_type * const ret = (malloc)();
456 if (ret == 0)
457 return ret;
458 try { new (ret) element_type(a0, a1, a2); }
459 catch (...) { (free)(chunk: ret); throw; }
460 return ret;
461}
462template <typename T0, typename T1, typename T2>
463element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2)
464{
465 element_type * const ret = (malloc)();
466 if (ret == 0)
467 return ret;
468 try { new (ret) element_type(a0, a1, a2); }
469 catch (...) { (free)(chunk: ret); throw; }
470 return ret;
471}
472template <typename T0, typename T1, typename T2>
473element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2)
474{
475 element_type * const ret = (malloc)();
476 if (ret == 0)
477 return ret;
478 try { new (ret) element_type(a0, a1, a2); }
479 catch (...) { (free)(chunk: ret); throw; }
480 return ret;
481}
482template <typename T0, typename T1, typename T2>
483element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2)
484{
485 element_type * const ret = (malloc)();
486 if (ret == 0)
487 return ret;
488 try { new (ret) element_type(a0, a1, a2); }
489 catch (...) { (free)(chunk: ret); throw; }
490 return ret;
491}
492template <typename T0, typename T1, typename T2>
493element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2)
494{
495 element_type * const ret = (malloc)();
496 if (ret == 0)
497 return ret;
498 try { new (ret) element_type(a0, a1, a2); }
499 catch (...) { (free)(chunk: ret); throw; }
500 return ret;
501}
502template <typename T0, typename T1, typename T2>
503element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2)
504{
505 element_type * const ret = (malloc)();
506 if (ret == 0)
507 return ret;
508 try { new (ret) element_type(a0, a1, a2); }
509 catch (...) { (free)(chunk: ret); throw; }
510 return ret;
511}
512template <typename T0, typename T1, typename T2>
513element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
514{
515 element_type * const ret = (malloc)();
516 if (ret == 0)
517 return ret;
518 try { new (ret) element_type(a0, a1, a2); }
519 catch (...) { (free)(chunk: ret); throw; }
520 return ret;
521}
522template <typename T0, typename T1, typename T2>
523element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
524{
525 element_type * const ret = (malloc)();
526 if (ret == 0)
527 return ret;
528 try { new (ret) element_type(a0, a1, a2); }
529 catch (...) { (free)(chunk: ret); throw; }
530 return ret;
531}
532template <typename T0, typename T1, typename T2>
533element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2)
534{
535 element_type * const ret = (malloc)();
536 if (ret == 0)
537 return ret;
538 try { new (ret) element_type(a0, a1, a2); }
539 catch (...) { (free)(chunk: ret); throw; }
540 return ret;
541}
542template <typename T0, typename T1, typename T2>
543element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2)
544{
545 element_type * const ret = (malloc)();
546 if (ret == 0)
547 return ret;
548 try { new (ret) element_type(a0, a1, a2); }
549 catch (...) { (free)(chunk: ret); throw; }
550 return ret;
551}
552template <typename T0, typename T1, typename T2>
553element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2)
554{
555 element_type * const ret = (malloc)();
556 if (ret == 0)
557 return ret;
558 try { new (ret) element_type(a0, a1, a2); }
559 catch (...) { (free)(chunk: ret); throw; }
560 return ret;
561}
562template <typename T0, typename T1, typename T2>
563element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2)
564{
565 element_type * const ret = (malloc)();
566 if (ret == 0)
567 return ret;
568 try { new (ret) element_type(a0, a1, a2); }
569 catch (...) { (free)(chunk: ret); throw; }
570 return ret;
571}
572template <typename T0, typename T1, typename T2>
573element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2)
574{
575 element_type * const ret = (malloc)();
576 if (ret == 0)
577 return ret;
578 try { new (ret) element_type(a0, a1, a2); }
579 catch (...) { (free)(chunk: ret); throw; }
580 return ret;
581}
582template <typename T0, typename T1, typename T2>
583element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2)
584{
585 element_type * const ret = (malloc)();
586 if (ret == 0)
587 return ret;
588 try { new (ret) element_type(a0, a1, a2); }
589 catch (...) { (free)(chunk: ret); throw; }
590 return ret;
591}
592template <typename T0, typename T1, typename T2>
593element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2)
594{
595 element_type * const ret = (malloc)();
596 if (ret == 0)
597 return ret;
598 try { new (ret) element_type(a0, a1, a2); }
599 catch (...) { (free)(chunk: ret); throw; }
600 return ret;
601}
602template <typename T0, typename T1, typename T2>
603element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2)
604{
605 element_type * const ret = (malloc)();
606 if (ret == 0)
607 return ret;
608 try { new (ret) element_type(a0, a1, a2); }
609 catch (...) { (free)(chunk: ret); throw; }
610 return ret;
611}
612template <typename T0, typename T1, typename T2>
613element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2)
614{
615 element_type * const ret = (malloc)();
616 if (ret == 0)
617 return ret;
618 try { new (ret) element_type(a0, a1, a2); }
619 catch (...) { (free)(chunk: ret); throw; }
620 return ret;
621}
622template <typename T0, typename T1, typename T2>
623element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2)
624{
625 element_type * const ret = (malloc)();
626 if (ret == 0)
627 return ret;
628 try { new (ret) element_type(a0, a1, a2); }
629 catch (...) { (free)(chunk: ret); throw; }
630 return ret;
631}
632template <typename T0, typename T1, typename T2>
633element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
634{
635 element_type * const ret = (malloc)();
636 if (ret == 0)
637 return ret;
638 try { new (ret) element_type(a0, a1, a2); }
639 catch (...) { (free)(chunk: ret); throw; }
640 return ret;
641}
642template <typename T0, typename T1, typename T2>
643element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
644{
645 element_type * const ret = (malloc)();
646 if (ret == 0)
647 return ret;
648 try { new (ret) element_type(a0, a1, a2); }
649 catch (...) { (free)(chunk: ret); throw; }
650 return ret;
651}
652template <typename T0, typename T1, typename T2>
653element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2)
654{
655 element_type * const ret = (malloc)();
656 if (ret == 0)
657 return ret;
658 try { new (ret) element_type(a0, a1, a2); }
659 catch (...) { (free)(chunk: ret); throw; }
660 return ret;
661}
662template <typename T0, typename T1, typename T2>
663element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2)
664{
665 element_type * const ret = (malloc)();
666 if (ret == 0)
667 return ret;
668 try { new (ret) element_type(a0, a1, a2); }
669 catch (...) { (free)(chunk: ret); throw; }
670 return ret;
671}
672template <typename T0, typename T1, typename T2>
673element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
674{
675 element_type * const ret = (malloc)();
676 if (ret == 0)
677 return ret;
678 try { new (ret) element_type(a0, a1, a2); }
679 catch (...) { (free)(chunk: ret); throw; }
680 return ret;
681}
682template <typename T0, typename T1, typename T2>
683element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
684{
685 element_type * const ret = (malloc)();
686 if (ret == 0)
687 return ret;
688 try { new (ret) element_type(a0, a1, a2); }
689 catch (...) { (free)(chunk: ret); throw; }
690 return ret;
691}
692template <typename T0, typename T1, typename T2>
693element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2)
694{
695 element_type * const ret = (malloc)();
696 if (ret == 0)
697 return ret;
698 try { new (ret) element_type(a0, a1, a2); }
699 catch (...) { (free)(chunk: ret); throw; }
700 return ret;
701}
702template <typename T0, typename T1, typename T2>
703element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2)
704{
705 element_type * const ret = (malloc)();
706 if (ret == 0)
707 return ret;
708 try { new (ret) element_type(a0, a1, a2); }
709 catch (...) { (free)(chunk: ret); throw; }
710 return ret;
711}
712template <typename T0, typename T1, typename T2>
713element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2)
714{
715 element_type * const ret = (malloc)();
716 if (ret == 0)
717 return ret;
718 try { new (ret) element_type(a0, a1, a2); }
719 catch (...) { (free)(chunk: ret); throw; }
720 return ret;
721}
722template <typename T0, typename T1, typename T2>
723element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2)
724{
725 element_type * const ret = (malloc)();
726 if (ret == 0)
727 return ret;
728 try { new (ret) element_type(a0, a1, a2); }
729 catch (...) { (free)(chunk: ret); throw; }
730 return ret;
731}
732template <typename T0, typename T1, typename T2>
733element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2)
734{
735 element_type * const ret = (malloc)();
736 if (ret == 0)
737 return ret;
738 try { new (ret) element_type(a0, a1, a2); }
739 catch (...) { (free)(chunk: ret); throw; }
740 return ret;
741}
742template <typename T0, typename T1, typename T2>
743element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2)
744{
745 element_type * const ret = (malloc)();
746 if (ret == 0)
747 return ret;
748 try { new (ret) element_type(a0, a1, a2); }
749 catch (...) { (free)(chunk: ret); throw; }
750 return ret;
751}
752template <typename T0, typename T1, typename T2>
753element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
754{
755 element_type * const ret = (malloc)();
756 if (ret == 0)
757 return ret;
758 try { new (ret) element_type(a0, a1, a2); }
759 catch (...) { (free)(chunk: ret); throw; }
760 return ret;
761}
762template <typename T0, typename T1, typename T2>
763element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
764{
765 element_type * const ret = (malloc)();
766 if (ret == 0)
767 return ret;
768 try { new (ret) element_type(a0, a1, a2); }
769 catch (...) { (free)(chunk: ret); throw; }
770 return ret;
771}
772template <typename T0, typename T1, typename T2>
773element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2)
774{
775 element_type * const ret = (malloc)();
776 if (ret == 0)
777 return ret;
778 try { new (ret) element_type(a0, a1, a2); }
779 catch (...) { (free)(chunk: ret); throw; }
780 return ret;
781}
782template <typename T0, typename T1, typename T2>
783element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2)
784{
785 element_type * const ret = (malloc)();
786 if (ret == 0)
787 return ret;
788 try { new (ret) element_type(a0, a1, a2); }
789 catch (...) { (free)(chunk: ret); throw; }
790 return ret;
791}
792template <typename T0, typename T1, typename T2>
793element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
794{
795 element_type * const ret = (malloc)();
796 if (ret == 0)
797 return ret;
798 try { new (ret) element_type(a0, a1, a2); }
799 catch (...) { (free)(chunk: ret); throw; }
800 return ret;
801}
802template <typename T0, typename T1, typename T2>
803element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
804{
805 element_type * const ret = (malloc)();
806 if (ret == 0)
807 return ret;
808 try { new (ret) element_type(a0, a1, a2); }
809 catch (...) { (free)(chunk: ret); throw; }
810 return ret;
811}
812template <typename T0, typename T1, typename T2>
813element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
814{
815 element_type * const ret = (malloc)();
816 if (ret == 0)
817 return ret;
818 try { new (ret) element_type(a0, a1, a2); }
819 catch (...) { (free)(chunk: ret); throw; }
820 return ret;
821}
822template <typename T0, typename T1, typename T2>
823element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
824{
825 element_type * const ret = (malloc)();
826 if (ret == 0)
827 return ret;
828 try { new (ret) element_type(a0, a1, a2); }
829 catch (...) { (free)(chunk: ret); throw; }
830 return ret;
831}
832template <typename T0, typename T1, typename T2>
833element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
834{
835 element_type * const ret = (malloc)();
836 if (ret == 0)
837 return ret;
838 try { new (ret) element_type(a0, a1, a2); }
839 catch (...) { (free)(chunk: ret); throw; }
840 return ret;
841}
842template <typename T0, typename T1, typename T2>
843element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
844{
845 element_type * const ret = (malloc)();
846 if (ret == 0)
847 return ret;
848 try { new (ret) element_type(a0, a1, a2); }
849 catch (...) { (free)(chunk: ret); throw; }
850 return ret;
851}
852
853

source code of boost/libs/pool/include/boost/pool/detail/pool_construct.ipp