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