cpp03_zone.hpp

00001 //
00002 // MessagePack for C++ memory pool
00003 //
00004 // Copyright (C) 2008-2010 FURUHASHI Sadayuki
00005 //
00006 //    Distributed under the Boost Software License, Version 1.0.
00007 //    (See accompanying file LICENSE_1_0.txt or copy at
00008 //    http://www.boost.org/LICENSE_1_0.txt)
00009 //
00010 #ifndef MSGPACK_CPP03_ZONE_HPP
00011 #define MSGPACK_CPP03_ZONE_HPP
00012 
00013 #include <cstdlib>
00014 #include <memory>
00015 #include <vector>
00016 
00017 #include "msgpack/versioning.hpp"
00018 
00019 #ifndef MSGPACK_ZONE_CHUNK_SIZE
00020     #if defined(__MBED__)
00021         #define MSGPACK_ZONE_CHUNK_SIZE 512
00022     #elif defined(__AVR__)
00023         #define MSGPACK_ZONE_CHUNK_SIZE 128
00024     #else
00025         #define MSGPACK_ZONE_CHUNK_SIZE 8192
00026     #endif
00027 #endif
00028 
00029 #ifndef MSGPACK_ZONE_ALIGN
00030 #define MSGPACK_ZONE_ALIGN sizeof(void*)
00031 #endif
00032 
00033 
00034 namespace msgpack {
00035 
00036 /// @cond
00037 MSGPACK_API_VERSION_NAMESPACE(v1) {
00038 /// @endcond
00039 
00040 class zone {
00041     struct finalizer {
00042         finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {}
00043         void operator()() { m_func(m_data); }
00044         void (*m_func)(void*);
00045         void* m_data;
00046     };
00047     struct finalizer_array {
00048         finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {}
00049         void call() {
00050             finalizer* fin = m_tail;
00051             for(; fin != m_array; --fin) (*(fin-1))();
00052         }
00053         ~finalizer_array() {
00054             call();
00055             ::free(m_array);
00056         }
00057         void clear() {
00058             call();
00059             m_tail = m_array;
00060         }
00061         void push(void (*func)(void* data), void* data)
00062         {
00063             finalizer* fin = m_tail;
00064 
00065             if(fin == m_end) {
00066                 push_expand(func, data);
00067                 return;
00068             }
00069 
00070             fin->m_func = func;
00071             fin->m_data = data;
00072 
00073             ++m_tail;
00074         }
00075         void push_expand(void (*func)(void*), void* data) {
00076             const size_t nused = m_end - m_array;
00077             size_t nnext;
00078             if(nused == 0) {
00079                 nnext = (sizeof(finalizer) < 72/2) ?
00080                     72 / sizeof(finalizer) : 8;
00081             } else {
00082                 nnext = nused * 2;
00083             }
00084             finalizer* tmp =
00085                 static_cast<finalizer*>(::realloc(m_array, sizeof(finalizer) * nnext));
00086             if(!tmp) {
00087                 printf("throw bad_alloc()\n");
00088 //                throw std::bad_alloc();
00089             }
00090             m_array     = tmp;
00091             m_end   = tmp + nnext;
00092             m_tail  = tmp + nused;
00093             new (m_tail) finalizer(func, data);
00094 
00095             ++m_tail;
00096         }
00097         finalizer* m_tail;
00098         finalizer* m_end;
00099         finalizer* m_array;
00100     };
00101     struct chunk {
00102         chunk* m_next;
00103     };
00104     struct chunk_list {
00105         chunk_list(size_t chunk_size)
00106         {
00107             chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
00108             if(!c) {
00109                 printf("throw bad_alloc()\n");
00110 //                throw std::bad_alloc();
00111             }
00112 
00113             m_head = c;
00114             m_free = chunk_size;
00115             m_ptr  = reinterpret_cast<char*>(c) + sizeof(chunk);
00116             c->m_next = nullptr;
00117         }
00118         ~chunk_list()
00119         {
00120             chunk* c = m_head;
00121             while(c) {
00122                 chunk* n = c->m_next;
00123                 ::free(c);
00124                 c = n;
00125             }
00126         }
00127         void clear(size_t chunk_size)
00128         {
00129             chunk* c = m_head;
00130             while(true) {
00131                 chunk* n = c->m_next;
00132                 if(n) {
00133                     ::free(c);
00134                     c = n;
00135                 } else {
00136                     break;
00137                 }
00138             }
00139             m_head->m_next = nullptr;
00140             m_free = chunk_size;
00141             m_ptr  = reinterpret_cast<char*>(m_head) + sizeof(chunk);
00142         }
00143         size_t m_free;
00144         char* m_ptr;
00145         chunk* m_head;
00146     };
00147     size_t m_chunk_size;
00148     chunk_list m_chunk_list;
00149     finalizer_array m_finalizer_array;
00150 
00151 public:
00152     zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */;
00153 
00154 public:
00155     void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN);
00156     void* allocate_no_align(size_t size);
00157 
00158     void push_finalizer(void (*func)(void*), void* data);
00159 
00160     template <typename T>
00161     void push_finalizer(msgpack::unique_ptr<T> obj);
00162 
00163     void clear();
00164 
00165     void swap(zone& o);
00166     static void* operator new(std::size_t size)
00167     {
00168         void* p = ::malloc(size);
00169         if (!p) {
00170             printf("throw bad_alloc()\n");
00171 //            throw std::bad_alloc();
00172         }
00173         return p;
00174     }
00175     static void operator delete(void *p) /* throw() */
00176     {
00177         ::free(p);
00178     }
00179     static void* operator new(std::size_t size, void* place) /* throw() */
00180     {
00181         return ::operator new(size, place);
00182     }
00183     static void operator delete(void* p, void* place) /* throw() */
00184     {
00185         ::operator delete(p, place);
00186     }
00187     /// @cond
00188     
00189     template <typename T>
00190     T* allocate();
00191     
00192     template <typename T, typename A1>
00193     T* allocate(A1 a1);
00194     
00195     template <typename T, typename A1, typename A2>
00196     T* allocate(A1 a1, A2 a2);
00197     
00198     template <typename T, typename A1, typename A2, typename A3>
00199     T* allocate(A1 a1, A2 a2, A3 a3);
00200     
00201     template <typename T, typename A1, typename A2, typename A3, typename A4>
00202     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4);
00203     
00204     template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
00205     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5);
00206     
00207     template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
00208     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6);
00209     
00210     template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
00211     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7);
00212     
00213     template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
00214     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8);
00215     
00216     template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
00217     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9);
00218     
00219     template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
00220     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10);
00221     
00222     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>
00223     T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11);
00224     
00225     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>
00226     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);
00227     
00228     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>
00229     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);
00230     
00231     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>
00232     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);
00233     
00234     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>
00235     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);
00236     
00237     /// @endcond
00238 
00239 private:
00240     void undo_allocate(size_t size);
00241 
00242     template <typename T>
00243     static void object_destruct(void* obj);
00244 
00245     template <typename T>
00246     static void object_delete(void* obj);
00247 
00248     void* allocate_expand(size_t size);
00249 private:
00250     zone(const zone&);
00251     zone& operator=(const zone&);
00252 };
00253 
00254 inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
00255 {
00256 }
00257 
00258 inline void* zone::allocate_align(size_t size, size_t align)
00259 {
00260     char* aligned =
00261         reinterpret_cast<char*>(
00262             reinterpret_cast<size_t>(
00263                 (m_chunk_list.m_ptr + (align - 1))) / align * align);
00264     size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
00265     if(m_chunk_list.m_free >= adjusted_size) {
00266         m_chunk_list.m_free -= adjusted_size;
00267         m_chunk_list.m_ptr  += adjusted_size;
00268         return aligned;
00269     }
00270     return reinterpret_cast<char*>(
00271         reinterpret_cast<size_t>(
00272             allocate_expand(size + (align - 1))) / align * align);
00273 }
00274 
00275 inline void* zone::allocate_no_align(size_t size)
00276 {
00277     if(m_chunk_list.m_free < size) {
00278         return allocate_expand(size);
00279     }
00280 
00281     char* ptr = m_chunk_list.m_ptr;
00282     m_chunk_list.m_free -= size;
00283     m_chunk_list.m_ptr  += size;
00284 
00285     return ptr;
00286 }
00287 
00288 inline void* zone::allocate_expand(size_t size)
00289 {
00290     chunk_list* const cl = &m_chunk_list;
00291 
00292     size_t sz = m_chunk_size;
00293 
00294     while(sz < size) {
00295         size_t tmp_sz = sz * 2;
00296         if (tmp_sz <= sz) {
00297             sz = size;
00298             break;
00299         }
00300         sz = tmp_sz;
00301     }
00302 
00303     chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
00304     if (!c) {
00305         printf("throw bad_alloc()\n");
00306 //        throw std::bad_alloc();
00307     }
00308 
00309     char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
00310 
00311     c->m_next  = cl->m_head;
00312     cl->m_head = c;
00313     cl->m_free = sz - size;
00314     cl->m_ptr  = ptr + size;
00315 
00316     return ptr;
00317 }
00318 
00319 inline void zone::push_finalizer(void (*func)(void*), void* data)
00320 {
00321     m_finalizer_array.push(func, data);
00322 }
00323 
00324 template <typename T>
00325 inline void zone::push_finalizer(msgpack::unique_ptr<T> obj)
00326 {
00327     m_finalizer_array.push(&zone::object_delete<T>, obj.release());
00328 }
00329 
00330 inline void zone::clear()
00331 {
00332     m_finalizer_array.clear();
00333     m_chunk_list.clear(m_chunk_size);
00334 }
00335 
00336 inline void zone::swap(zone& o)
00337 {
00338     using std::swap;
00339     swap(m_chunk_size, o.m_chunk_size);
00340     swap(m_chunk_list, o.m_chunk_list);
00341     swap(m_finalizer_array, o.m_finalizer_array);
00342 }
00343 
00344 template <typename T>
00345 void zone::object_destruct(void* obj)
00346 {
00347     static_cast<T*>(obj)->~T();
00348 }
00349 
00350 template <typename T>
00351 void zone::object_delete(void* obj)
00352 {
00353     delete static_cast<T*>(obj);
00354 }
00355 
00356 inline void zone::undo_allocate(size_t size)
00357 {
00358     m_chunk_list.m_ptr  -= size;
00359     m_chunk_list.m_free += size;
00360 }
00361 
00362 inline std::size_t aligned_size(
00363     std::size_t size,
00364     std::size_t align = MSGPACK_ZONE_ALIGN) {
00365     return (size + align - 1) / align * align;
00366 }
00367 
00368 /// @cond
00369 
00370 template <typename T>
00371 T* zone::allocate()
00372 {
00373     void* x = allocate_align(sizeof(T));
00374     try {
00375         m_finalizer_array.push(&zone::object_destruct<T>, x);
00376     } catch (...) {
00377         undo_allocate(sizeof(T));
00378         throw;
00379     }
00380     try {
00381         return new (x) T();
00382     } catch (...) {
00383         --m_finalizer_array.m_tail;
00384         undo_allocate(sizeof(T));
00385         throw;
00386     }
00387 }
00388 
00389 template <typename T, typename A1>
00390 T* zone::allocate(A1 a1)
00391 {
00392     void* x = allocate_align(sizeof(T));
00393     try {
00394         m_finalizer_array.push(&zone::object_destruct<T>, x);
00395     } catch (...) {
00396         undo_allocate(sizeof(T));
00397         throw;
00398     }
00399     try {
00400         return new (x) T(a1);
00401     } catch (...) {
00402         --m_finalizer_array.m_tail;
00403         undo_allocate(sizeof(T));
00404         throw;
00405     }
00406 }
00407 
00408 template <typename T, typename A1, typename A2>
00409 T* zone::allocate(A1 a1, A2 a2)
00410 {
00411     void* x = allocate_align(sizeof(T));
00412     try {
00413         m_finalizer_array.push(&zone::object_destruct<T>, x);
00414     } catch (...) {
00415         undo_allocate(sizeof(T));
00416         throw;
00417     }
00418     try {
00419         return new (x) T(a1, a2);
00420     } catch (...) {
00421         --m_finalizer_array.m_tail;
00422         undo_allocate(sizeof(T));
00423         throw;
00424     }
00425 }
00426 
00427 template <typename T, typename A1, typename A2, typename A3>
00428 T* zone::allocate(A1 a1, A2 a2, A3 a3)
00429 {
00430     void* x = allocate_align(sizeof(T));
00431     try {
00432         m_finalizer_array.push(&zone::object_destruct<T>, x);
00433     } catch (...) {
00434         undo_allocate(sizeof(T));
00435         throw;
00436     }
00437     try {
00438         return new (x) T(a1, a2, a3);
00439     } catch (...) {
00440         --m_finalizer_array.m_tail;
00441         undo_allocate(sizeof(T));
00442         throw;
00443     }
00444 }
00445 
00446 template <typename T, typename A1, typename A2, typename A3, typename A4>
00447 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4)
00448 {
00449     void* x = allocate_align(sizeof(T));
00450     try {
00451         m_finalizer_array.push(&zone::object_destruct<T>, x);
00452     } catch (...) {
00453         undo_allocate(sizeof(T));
00454         throw;
00455     }
00456     try {
00457         return new (x) T(a1, a2, a3, a4);
00458     } catch (...) {
00459         --m_finalizer_array.m_tail;
00460         undo_allocate(sizeof(T));
00461         throw;
00462     }
00463 }
00464 
00465 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
00466 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00467 {
00468     void* x = allocate_align(sizeof(T));
00469     try {
00470         m_finalizer_array.push(&zone::object_destruct<T>, x);
00471     } catch (...) {
00472         undo_allocate(sizeof(T));
00473         throw;
00474     }
00475     try {
00476         return new (x) T(a1, a2, a3, a4, a5);
00477     } catch (...) {
00478         --m_finalizer_array.m_tail;
00479         undo_allocate(sizeof(T));
00480         throw;
00481     }
00482 }
00483 
00484 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
00485 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00486 {
00487     void* x = allocate_align(sizeof(T));
00488     try {
00489         m_finalizer_array.push(&zone::object_destruct<T>, x);
00490     } catch (...) {
00491         undo_allocate(sizeof(T));
00492         throw;
00493     }
00494     try {
00495         return new (x) T(a1, a2, a3, a4, a5, a6);
00496     } catch (...) {
00497         --m_finalizer_array.m_tail;
00498         undo_allocate(sizeof(T));
00499         throw;
00500     }
00501 }
00502 
00503 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
00504 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00505 {
00506     void* x = allocate_align(sizeof(T));
00507     try {
00508         m_finalizer_array.push(&zone::object_destruct<T>, x);
00509     } catch (...) {
00510         undo_allocate(sizeof(T));
00511         throw;
00512     }
00513     try {
00514         return new (x) T(a1, a2, a3, a4, a5, a6, a7);
00515     } catch (...) {
00516         --m_finalizer_array.m_tail;
00517         undo_allocate(sizeof(T));
00518         throw;
00519     }
00520 }
00521 
00522 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
00523 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
00524 {
00525     void* x = allocate_align(sizeof(T));
00526     try {
00527         m_finalizer_array.push(&zone::object_destruct<T>, x);
00528     } catch (...) {
00529         undo_allocate(sizeof(T));
00530         throw;
00531     }
00532     try {
00533         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8);
00534     } catch (...) {
00535         --m_finalizer_array.m_tail;
00536         undo_allocate(sizeof(T));
00537         throw;
00538     }
00539 }
00540 
00541 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
00542 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
00543 {
00544     void* x = allocate_align(sizeof(T));
00545     try {
00546         m_finalizer_array.push(&zone::object_destruct<T>, x);
00547     } catch (...) {
00548         undo_allocate(sizeof(T));
00549         throw;
00550     }
00551     try {
00552         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
00553     } catch (...) {
00554         --m_finalizer_array.m_tail;
00555         undo_allocate(sizeof(T));
00556         throw;
00557     }
00558 }
00559 
00560 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
00561 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
00562 {
00563     void* x = allocate_align(sizeof(T));
00564     try {
00565         m_finalizer_array.push(&zone::object_destruct<T>, x);
00566     } catch (...) {
00567         undo_allocate(sizeof(T));
00568         throw;
00569     }
00570     try {
00571         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
00572     } catch (...) {
00573         --m_finalizer_array.m_tail;
00574         undo_allocate(sizeof(T));
00575         throw;
00576     }
00577 }
00578 
00579 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>
00580 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)
00581 {
00582     void* x = allocate_align(sizeof(T));
00583     try {
00584         m_finalizer_array.push(&zone::object_destruct<T>, x);
00585     } catch (...) {
00586         undo_allocate(sizeof(T));
00587         throw;
00588     }
00589     try {
00590         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
00591     } catch (...) {
00592         --m_finalizer_array.m_tail;
00593         undo_allocate(sizeof(T));
00594         throw;
00595     }
00596 }
00597 
00598 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>
00599 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)
00600 {
00601     void* x = allocate_align(sizeof(T));
00602     try {
00603         m_finalizer_array.push(&zone::object_destruct<T>, x);
00604     } catch (...) {
00605         undo_allocate(sizeof(T));
00606         throw;
00607     }
00608     try {
00609         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
00610     } catch (...) {
00611         --m_finalizer_array.m_tail;
00612         undo_allocate(sizeof(T));
00613         throw;
00614     }
00615 }
00616 
00617 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>
00618 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)
00619 {
00620     void* x = allocate_align(sizeof(T));
00621     try {
00622         m_finalizer_array.push(&zone::object_destruct<T>, x);
00623     } catch (...) {
00624         undo_allocate(sizeof(T));
00625         throw;
00626     }
00627     try {
00628         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
00629     } catch (...) {
00630         --m_finalizer_array.m_tail;
00631         undo_allocate(sizeof(T));
00632         throw;
00633     }
00634 }
00635 
00636 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>
00637 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)
00638 {
00639     void* x = allocate_align(sizeof(T));
00640     try {
00641         m_finalizer_array.push(&zone::object_destruct<T>, x);
00642     } catch (...) {
00643         undo_allocate(sizeof(T));
00644         throw;
00645     }
00646     try {
00647         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
00648     } catch (...) {
00649         --m_finalizer_array.m_tail;
00650         undo_allocate(sizeof(T));
00651         throw;
00652     }
00653 }
00654 
00655 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>
00656 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)
00657 {
00658     void* x = allocate_align(sizeof(T));
00659     try {
00660         m_finalizer_array.push(&zone::object_destruct<T>, x);
00661     } catch (...) {
00662         undo_allocate(sizeof(T));
00663         throw;
00664     }
00665     try {
00666         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
00667     } catch (...) {
00668         --m_finalizer_array.m_tail;
00669         undo_allocate(sizeof(T));
00670         throw;
00671     }
00672 }
00673 
00674 /// @endcond
00675 
00676 /// @cond
00677 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
00678 /// @endcond
00679 
00680 }  // namespace msgpack
00681 
00682 #endif // MSGPACK_CPP03_ZONE_HPP