Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_34_1/boost/pool/detail/pool_construct.inc @ 35

Last change on this file since 35 was 29, checked in by landauf, 17 years ago

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