• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(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)(ret); throw; }
850  return ret;
851}
852
853