Pooling.hpp

   1 /* Cycript - Inlining/Optimizing JavaScript Compiler
   2  * Copyright (C) 2009  Jay Freeman (saurik)
   3 */
   4
   5 /* Modified BSD License {{{ */
   6 /*
   7  *        Redistribution and use in source and binary
   8  * forms, with or without modification, are permitted
   9  * provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the
  12  *    above copyright notice, this list of conditions
  13  *    and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the
  15  *    above copyright notice, this list of conditions
  16  *    and the following disclaimer in the documentation
  17  *    and/or other materials provided with the
  18  *    distribution.
  19  * 3. The name of the author may not be used to endorse
  20  *    or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  25  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 */
  38 /* }}} */
  39
  40 #ifndef CYPOOLING_HPP
  41 #define CYPOOLING_HPP
  42
  43 #include <apr_pools.h>
  44 #include <apr_strings.h>
  45
  46 #include "Exception.hpp"
  47 #include "Local.hpp"
  48 #include "Standard.hpp"
  49
  50 #include <cstdlib>
  51
  52 _finline void *operator new(size_t size, apr_pool_t *pool) {
  53     return apr_palloc(pool, size);
  54 }
  55
  56 _finline void *operator new [](size_t size, apr_pool_t *pool) {
  57     return apr_palloc(pool, size);
  58 }
  59
  60 class CYPool {
  61   private:
  62     apr_pool_t *pool_;
  63
  64   public:
  65     CYPool(apr_pool_t *pool = NULL) {
  66         _aprcall(apr_pool_create(&pool_, pool));
  67     }
  68
  69     ~CYPool() {
  70         apr_pool_destroy(pool_);
  71     }
  72
  73     void Clear() {
  74         apr_pool_clear(pool_);
  75     }
  76
  77     operator apr_pool_t *() const {
  78         return pool_;
  79     }
  80
  81     char *operator ()(const char *data) const {
  82         return apr_pstrdup(pool_, data);
  83     }
  84
  85     char *operator ()(const char *data, size_t size) const {
  86         return apr_pstrndup(pool_, data, size);
  87     }
  88 };
  89
  90 struct CYData {
  91     apr_pool_t *pool_;
  92     unsigned count_;
  93
  94     CYData() :
  95         count_(1)
  96     {
  97     }
  98
  99     virtual ~CYData() {
 100     }
 101
 102     static void *operator new(size_t size, apr_pool_t *pool) {
 103         void *data(apr_palloc(pool, size));
 104         reinterpret_cast<CYData *>(data)->pool_ = pool;
 105         return data;
 106     }
 107
 108     static void *operator new(size_t size) {
 109         apr_pool_t *pool;
 110         _aprcall(apr_pool_create(&pool, NULL));
 111         return operator new(size, pool);
 112     }
 113
 114     static void operator delete(void *data) {
 115         apr_pool_destroy(reinterpret_cast<CYData *>(data)->pool_);
 116     }
 117 };
 118
 119 template <typename Type_>
 120 struct CYPoolAllocator {
 121     apr_pool_t *pool_;
 122
 123     typedef Type_ value_type;
 124     typedef value_type *pointer;
 125     typedef const value_type *const_pointer;
 126     typedef value_type &reference;
 127     typedef const value_type &const_reference;
 128     typedef std::size_t size_type;
 129     typedef std::ptrdiff_t difference_type;
 130
 131     CYPoolAllocator() :
 132         pool_(NULL)
 133     {
 134     }
 135
 136     template <typename Right_>
 137     CYPoolAllocator(const CYPoolAllocator<Right_> &rhs) :
 138         pool_(rhs.pool_)
 139     {
 140     }
 141
 142     pointer allocate(size_type size, const void *hint = 0) {
 143         return reinterpret_cast<pointer>(apr_palloc(pool_, size));
 144     }
 145
 146     void deallocate(pointer data, size_type size) {
 147     }
 148
 149     void construct(pointer address, const Type_ &rhs) {
 150         new(address) Type_(rhs);
 151     }
 152
 153     void destroy(pointer address) {
 154         address->~Type_();
 155     }
 156
 157     template <typename Right_>
 158     inline bool operator==(const CYPoolAllocator<Right_> &rhs) {
 159         return pool_ == rhs.pool_;
 160     }
 161
 162     template <typename Right_>
 163     inline bool operator!=(const CYPoolAllocator<Right_> &rhs) {
 164         return !operator==(rhs);
 165     }
 166
 167     template <typename Right_>
 168     struct rebind {
 169         typedef CYPoolAllocator<Right_> other;
 170     };
 171 };
 172
 173 class CYLocalPool :
 174     public CYPool
 175 {
 176   private:
 177     CYLocal<apr_pool_t *> local_;
 178
 179   public:
 180     CYLocalPool() :
 181         CYPool(),
 182         local_(operator apr_pool_t *())
 183     {
 184     }
 185 };
 186
 187 #define $pool \
 188     CYLocal<apr_pool_t *>::Top()
 189
 190 #endif/*CYPOOLING_HPP*/