MessagePack for C++
cpp03_zone.hpp
Go to the documentation of this file.
1 //
2 // MessagePack for C++ memory pool
3 //
4 // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
5 //
6 // Distributed under the Boost Software License, Version 1.0.
7 // (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9 //
10 #ifndef MSGPACK_V1_CPP03_ZONE_HPP
11 #define MSGPACK_V1_CPP03_ZONE_HPP
12 
13 #include "msgpack/zone_decl.hpp"
14 
15 
16 namespace msgpack {
17 
21 
22 class zone {
23  struct finalizer {
24  finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {}
25  void operator()() { m_func(m_data); }
26  void (*m_func)(void*);
27  void* m_data;
28  };
29  struct finalizer_array {
30  finalizer_array():m_tail(MSGPACK_NULLPTR), m_end(MSGPACK_NULLPTR), m_array(MSGPACK_NULLPTR) {}
31  void call() {
32  finalizer* fin = m_tail;
33  for(; fin != m_array; --fin) (*(fin-1))();
34  }
35  ~finalizer_array() {
36  call();
37  ::free(m_array);
38  }
39  void clear() {
40  call();
41  m_tail = m_array;
42  }
43  void push(void (*func)(void* data), void* data)
44  {
45  finalizer* fin = m_tail;
46 
47  if(fin == m_end) {
48  push_expand(func, data);
49  return;
50  }
51 
52  fin->m_func = func;
53  fin->m_data = data;
54 
55  ++m_tail;
56  }
57  void push_expand(void (*func)(void*), void* data) {
58  const size_t nused = m_end - m_array;
59  size_t nnext;
60  if(nused == 0) {
61  nnext = (sizeof(finalizer) < 72/2) ?
62  72 / sizeof(finalizer) : 8;
63  } else {
64  nnext = nused * 2;
65  }
66  finalizer* tmp =
67  static_cast<finalizer*>(::realloc(m_array, sizeof(finalizer) * nnext));
68  if(!tmp) {
69  throw std::bad_alloc();
70  }
71  m_array = tmp;
72  m_end = tmp + nnext;
73  m_tail = tmp + nused;
74  new (m_tail) finalizer(func, data);
75 
76  ++m_tail;
77  }
78  finalizer* m_tail;
79  finalizer* m_end;
80  finalizer* m_array;
81  };
82  struct chunk {
83  chunk* m_next;
84  };
85  struct chunk_list {
86  chunk_list(size_t chunk_size)
87  {
88  chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
89  if(!c) {
90  throw std::bad_alloc();
91  }
92 
93  m_head = c;
94  m_free = chunk_size;
95  m_ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
96  c->m_next = MSGPACK_NULLPTR;
97  }
98  ~chunk_list()
99  {
100  chunk* c = m_head;
101  while(c) {
102  chunk* n = c->m_next;
103  ::free(c);
104  c = n;
105  }
106  }
107  void clear(size_t chunk_size)
108  {
109  chunk* c = m_head;
110  while(true) {
111  chunk* n = c->m_next;
112  if(n) {
113  ::free(c);
114  c = n;
115  } else {
116  m_head = c;
117  break;
118  }
119  }
120  m_head->m_next = MSGPACK_NULLPTR;
121  m_free = chunk_size;
122  m_ptr = reinterpret_cast<char*>(m_head) + sizeof(chunk);
123  }
124  size_t m_free;
125  char* m_ptr;
126  chunk* m_head;
127  };
128  size_t m_chunk_size;
129  chunk_list m_chunk_list;
130  finalizer_array m_finalizer_array;
131 
132 public:
133  zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */;
134 
135 public:
136  void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN);
137  void* allocate_no_align(size_t size);
138 
139  void push_finalizer(void (*func)(void*), void* data);
140 
141  template <typename T>
143 
144  void clear();
145 
146  void swap(zone& o);
147  static void* operator new(std::size_t size)
148  {
149  void* p = ::malloc(size);
150  if (!p) throw std::bad_alloc();
151  return p;
152  }
153  static void operator delete(void *p) /* throw() */
154  {
155  ::free(p);
156  }
157  static void* operator new(std::size_t size, void* place) /* throw() */
158  {
159  return ::operator new(size, place);
160  }
161  static void operator delete(void* p, void* place) /* throw() */
162  {
163  ::operator delete(p, place);
164  }
166 
167  template <typename T>
168  T* allocate();
169 
170  template <typename T, typename A1>
171  T* allocate(A1 a1);
172 
173  template <typename T, typename A1, typename A2>
174  T* allocate(A1 a1, A2 a2);
175 
176  template <typename T, typename A1, typename A2, typename A3>
177  T* allocate(A1 a1, A2 a2, A3 a3);
178 
179  template <typename T, typename A1, typename A2, typename A3, typename A4>
180  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4);
181 
182  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
183  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5);
184 
185  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
186  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6);
187 
188  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
189  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7);
190 
191  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
192  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8);
193 
194  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
195  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9);
196 
197  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
198  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10);
199 
200  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
201  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11);
202 
203  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
204  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12);
205 
206  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
207  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13);
208 
209  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
210  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14);
211 
212  template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
213  T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15);
214 
216 
217 private:
218  void undo_allocate(size_t size);
219 
220  template <typename T>
221  static void object_destruct(void* obj);
222 
223  template <typename T>
224  static void object_delete(void* obj);
225 
226  static char* get_aligned(char* ptr, size_t align);
227 
228  char* allocate_expand(size_t size);
229 private:
230  zone(const zone&);
231  zone& operator=(const zone&);
232 };
233 
234 inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
235 {
236 }
237 
238 inline char* zone::get_aligned(char* ptr, size_t align)
239 {
240  return
241  reinterpret_cast<char*>(
242  reinterpret_cast<size_t>(
243  (ptr + (align - 1))) / align * align);
244 }
245 
246 inline void* zone::allocate_align(size_t size, size_t align)
247 {
248  char* aligned = get_aligned(m_chunk_list.m_ptr, align);
249  size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
250  if (m_chunk_list.m_free < adjusted_size) {
251  size_t enough_size = size + align - 1;
252  char* ptr = allocate_expand(enough_size);
253  aligned = get_aligned(ptr, align);
254  adjusted_size = size + (aligned - m_chunk_list.m_ptr);
255  }
256  m_chunk_list.m_free -= adjusted_size;
257  m_chunk_list.m_ptr += adjusted_size;
258  return aligned;
259 }
260 
261 inline void* zone::allocate_no_align(size_t size)
262 {
263  char* ptr = m_chunk_list.m_ptr;
264  if(m_chunk_list.m_free < size) {
265  ptr = allocate_expand(size);
266  }
267  m_chunk_list.m_free -= size;
268  m_chunk_list.m_ptr += size;
269 
270  return ptr;
271 }
272 
273 inline char* zone::allocate_expand(size_t size)
274 {
275  chunk_list* const cl = &m_chunk_list;
276 
277  size_t sz = m_chunk_size;
278 
279  while(sz < size) {
280  size_t tmp_sz = sz * 2;
281  if (tmp_sz <= sz) {
282  sz = size;
283  break;
284  }
285  sz = tmp_sz;
286  }
287 
288  chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
289  if (!c) throw std::bad_alloc();
290 
291  char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
292 
293  c->m_next = cl->m_head;
294  cl->m_head = c;
295  cl->m_free = sz;
296  cl->m_ptr = ptr;
297 
298  return ptr;
299 }
300 
301 inline void zone::push_finalizer(void (*func)(void*), void* data)
302 {
303  m_finalizer_array.push(func, data);
304 }
305 
306 template <typename T>
308 {
309  m_finalizer_array.push(&zone::object_delete<T>, obj.release());
310 }
311 
312 inline void zone::clear()
313 {
314  m_finalizer_array.clear();
315  m_chunk_list.clear(m_chunk_size);
316 }
317 
318 inline void zone::swap(zone& o)
319 {
320  using std::swap;
321  swap(m_chunk_size, o.m_chunk_size);
322  swap(m_chunk_list, o.m_chunk_list);
323  swap(m_finalizer_array, o.m_finalizer_array);
324 }
325 
326 template <typename T>
327 void zone::object_destruct(void* obj)
328 {
329  static_cast<T*>(obj)->~T();
330 }
331 
332 template <typename T>
333 void zone::object_delete(void* obj)
334 {
335  delete static_cast<T*>(obj);
336 }
337 
338 inline void zone::undo_allocate(size_t size)
339 {
340  m_chunk_list.m_ptr -= size;
341  m_chunk_list.m_free += size;
342 }
343 
344 inline std::size_t aligned_size(
345  std::size_t size,
346  std::size_t align) {
347  return (size + align - 1) / align * align;
348 }
349 
351 
352 template <typename T>
353 T* zone::allocate()
354 {
355  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
356  try {
357  m_finalizer_array.push(&zone::object_destruct<T>, x);
358  } catch (...) {
359  undo_allocate(sizeof(T));
360  throw;
361  }
362  try {
363  return new (x) T();
364  } catch (...) {
365  --m_finalizer_array.m_tail;
366  undo_allocate(sizeof(T));
367  throw;
368  }
369 }
370 
371 template <typename T, typename A1>
372 T* zone::allocate(A1 a1)
373 {
374  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
375  try {
376  m_finalizer_array.push(&zone::object_destruct<T>, x);
377  } catch (...) {
378  undo_allocate(sizeof(T));
379  throw;
380  }
381  try {
382  return new (x) T(a1);
383  } catch (...) {
384  --m_finalizer_array.m_tail;
385  undo_allocate(sizeof(T));
386  throw;
387  }
388 }
389 
390 template <typename T, typename A1, typename A2>
391 T* zone::allocate(A1 a1, A2 a2)
392 {
393  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
394  try {
395  m_finalizer_array.push(&zone::object_destruct<T>, x);
396  } catch (...) {
397  undo_allocate(sizeof(T));
398  throw;
399  }
400  try {
401  return new (x) T(a1, a2);
402  } catch (...) {
403  --m_finalizer_array.m_tail;
404  undo_allocate(sizeof(T));
405  throw;
406  }
407 }
408 
409 template <typename T, typename A1, typename A2, typename A3>
410 T* zone::allocate(A1 a1, A2 a2, A3 a3)
411 {
412  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
413  try {
414  m_finalizer_array.push(&zone::object_destruct<T>, x);
415  } catch (...) {
416  undo_allocate(sizeof(T));
417  throw;
418  }
419  try {
420  return new (x) T(a1, a2, a3);
421  } catch (...) {
422  --m_finalizer_array.m_tail;
423  undo_allocate(sizeof(T));
424  throw;
425  }
426 }
427 
428 template <typename T, typename A1, typename A2, typename A3, typename A4>
429 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4)
430 {
431  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
432  try {
433  m_finalizer_array.push(&zone::object_destruct<T>, x);
434  } catch (...) {
435  undo_allocate(sizeof(T));
436  throw;
437  }
438  try {
439  return new (x) T(a1, a2, a3, a4);
440  } catch (...) {
441  --m_finalizer_array.m_tail;
442  undo_allocate(sizeof(T));
443  throw;
444  }
445 }
446 
447 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
448 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
449 {
450  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
451  try {
452  m_finalizer_array.push(&zone::object_destruct<T>, x);
453  } catch (...) {
454  undo_allocate(sizeof(T));
455  throw;
456  }
457  try {
458  return new (x) T(a1, a2, a3, a4, a5);
459  } catch (...) {
460  --m_finalizer_array.m_tail;
461  undo_allocate(sizeof(T));
462  throw;
463  }
464 }
465 
466 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
467 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
468 {
469  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
470  try {
471  m_finalizer_array.push(&zone::object_destruct<T>, x);
472  } catch (...) {
473  undo_allocate(sizeof(T));
474  throw;
475  }
476  try {
477  return new (x) T(a1, a2, a3, a4, a5, a6);
478  } catch (...) {
479  --m_finalizer_array.m_tail;
480  undo_allocate(sizeof(T));
481  throw;
482  }
483 }
484 
485 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
486 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
487 {
488  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
489  try {
490  m_finalizer_array.push(&zone::object_destruct<T>, x);
491  } catch (...) {
492  undo_allocate(sizeof(T));
493  throw;
494  }
495  try {
496  return new (x) T(a1, a2, a3, a4, a5, a6, a7);
497  } catch (...) {
498  --m_finalizer_array.m_tail;
499  undo_allocate(sizeof(T));
500  throw;
501  }
502 }
503 
504 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
505 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
506 {
507  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
508  try {
509  m_finalizer_array.push(&zone::object_destruct<T>, x);
510  } catch (...) {
511  undo_allocate(sizeof(T));
512  throw;
513  }
514  try {
515  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8);
516  } catch (...) {
517  --m_finalizer_array.m_tail;
518  undo_allocate(sizeof(T));
519  throw;
520  }
521 }
522 
523 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
524 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
525 {
526  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
527  try {
528  m_finalizer_array.push(&zone::object_destruct<T>, x);
529  } catch (...) {
530  undo_allocate(sizeof(T));
531  throw;
532  }
533  try {
534  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
535  } catch (...) {
536  --m_finalizer_array.m_tail;
537  undo_allocate(sizeof(T));
538  throw;
539  }
540 }
541 
542 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
543 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
544 {
545  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
546  try {
547  m_finalizer_array.push(&zone::object_destruct<T>, x);
548  } catch (...) {
549  undo_allocate(sizeof(T));
550  throw;
551  }
552  try {
553  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
554  } catch (...) {
555  --m_finalizer_array.m_tail;
556  undo_allocate(sizeof(T));
557  throw;
558  }
559 }
560 
561 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
562 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11)
563 {
564  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
565  try {
566  m_finalizer_array.push(&zone::object_destruct<T>, x);
567  } catch (...) {
568  undo_allocate(sizeof(T));
569  throw;
570  }
571  try {
572  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
573  } catch (...) {
574  --m_finalizer_array.m_tail;
575  undo_allocate(sizeof(T));
576  throw;
577  }
578 }
579 
580 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
581 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12)
582 {
583  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
584  try {
585  m_finalizer_array.push(&zone::object_destruct<T>, x);
586  } catch (...) {
587  undo_allocate(sizeof(T));
588  throw;
589  }
590  try {
591  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
592  } catch (...) {
593  --m_finalizer_array.m_tail;
594  undo_allocate(sizeof(T));
595  throw;
596  }
597 }
598 
599 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
600 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13)
601 {
602  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
603  try {
604  m_finalizer_array.push(&zone::object_destruct<T>, x);
605  } catch (...) {
606  undo_allocate(sizeof(T));
607  throw;
608  }
609  try {
610  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
611  } catch (...) {
612  --m_finalizer_array.m_tail;
613  undo_allocate(sizeof(T));
614  throw;
615  }
616 }
617 
618 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
619 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14)
620 {
621  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
622  try {
623  m_finalizer_array.push(&zone::object_destruct<T>, x);
624  } catch (...) {
625  undo_allocate(sizeof(T));
626  throw;
627  }
628  try {
629  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
630  } catch (...) {
631  --m_finalizer_array.m_tail;
632  undo_allocate(sizeof(T));
633  throw;
634  }
635 }
636 
637 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
638 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15)
639 {
640  void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
641  try {
642  m_finalizer_array.push(&zone::object_destruct<T>, x);
643  } catch (...) {
644  undo_allocate(sizeof(T));
645  throw;
646  }
647  try {
648  return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
649  } catch (...) {
650  --m_finalizer_array.m_tail;
651  undo_allocate(sizeof(T));
652  throw;
653  }
654 }
655 
657 
659 } // MSGPACK_API_VERSION_NAMESPACE(v1)
661 
662 } // namespace msgpack
663 
664 #endif // MSGPACK_V1_CPP03_ZONE_HPP
void * allocate_align(size_t size, size_t align=MSGPACK_ZONE_ALIGN)
Definition: cpp03_zone.hpp:246
void * allocate_no_align(size_t size)
Definition: cpp03_zone.hpp:261
Definition: adaptor_base.hpp:15
std::size_t aligned_size(std::size_t size, std::size_t align)
Definition: cpp03_zone.hpp:344
Definition: cpp03_zone.hpp:22
Definition: cpp_config_decl.hpp:47
void push_finalizer(void(*func)(void *), void *data)
Definition: cpp03_zone.hpp:301
#define MSGPACK_ZONE_ALIGN
Definition: cpp03_zone_decl.hpp:24
std::size_t size(T const &t)
Definition: size_equal_only.hpp:24
void clear()
Definition: cpp03_zone.hpp:312
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
#define MSGPACK_ZONE_CHUNK_SIZE
Definition: cpp03_zone_decl.hpp:20
#define MSGPACK_ZONE_ALIGNOF(type)
Definition: cpp03_zone_decl.hpp:30
void swap(zone &o)
Definition: cpp03_zone.hpp:318
T * allocate(Args... args)
Definition: cpp11_zone.hpp:336
zone(size_t chunk_size=MSGPACK_ZONE_CHUNK_SIZE)
Definition: cpp03_zone.hpp:234
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:35