[BACK]Return to pa_pool.h CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_pool.h between versions 1.45 and 1.81

version 1.45, 2001/03/26 08:27:25 version 1.81, 2002/06/28 09:59:00
Line 1 Line 1
 /** @file  /** @file
         Parser: pool class decl.          Parser: pool class decl.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
   
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$          $Id$
 */  */
Line 11 Line 11
 #ifndef PA_POOL_H  #ifndef PA_POOL_H
 #define PA_POOL_H  #define PA_POOL_H
   
 #include <stddef.h>  #include "pa_config_includes.h"
   
   #ifdef XML
   #       include "gdome.h"
   // for xmlChar
   #       include "libxml/tree.h"
   #endif
   
   // forwards
   
 class Exception;  class Exception;
 class Temp_exception;  class String;
   class Charset;
   class GdomeDOMString_auto_ptr;
   
 /**   /** 
         Pool mechanizm allows users not to free up allocated memory,          Pool mechanizm allows users not to free up allocated memory,
         leaving that problem to 'pools'.          leaving that problem to 'pools'.
   
         Also holds Exception object, which can be temporary set using   
         Temp_exception auto-object.  
   
         @see Pooled          @see Pooled
 */  */
   
 class Pool {  class Pool {
         friend Temp_exception;  
 public:  public:
   
         Pool(void *astorage) : fstorage(astorage), fcontext(0), ftag(0), fexception(0) {}          Pool(void *astorage);
   
         void set_context(void *acontext) { fcontext=acontext; }  
         void *context() { return fcontext; }  
   
         void set_tag(void *atag) { ftag=atag; }          //{@ statistics
         void *tag() { return ftag; }          size_t total_allocated() { return ftotal_allocated; }
           unsigned int total_times() { return ftotal_times; }
           //}@
   
         /// current exception object of the pool          void set_context(void *acontext) { fcontext=acontext; }
         Exception& exception() const { return *fexception; }          void *get_context() { return fcontext; }
   
         /// allocates some bytes on pool          /// allocates some bytes on pool
         void *malloc(size_t size) {          void *malloc(size_t size, int place=0) {
                 return check(real_malloc(size), size);                  return check(real_malloc(size, place), size);
         }          }
         /// allocates some bytes clearing them with zeros          /// allocates some bytes clearing them with zeros
         void *calloc(size_t size) {          void *calloc(size_t size) {
                 return check(real_calloc(size), size);                  return check(real_calloc(size), size);
         }          }
   
           /// registers a routine to clean up non-pooled allocations
           void register_cleanup(void (*cleanup) (void *), void *data) {
                   if(!real_register_cleanup(cleanup, data))
                           fail_register_cleanup();
           }
   
           //{@ source charset
           void set_source_charset(Charset& acharset);
           Charset& get_source_charset();
           //}@
   
           //{@ client charset
           void set_client_charset(Charset& charset);
           Charset& get_client_charset();
           //}@
   
   #ifdef XML
   
           /// @see Charset::transcode_cstr(xmlChar *s);
           const char *transcode_cstr(xmlChar *s);
           /// @see Charset::transcode(xmlChar *s);
           String& transcode(xmlChar *s);
           /// @see Charset::transcode_cstr(GdomeDOMString *s);
           const char *transcode_cstr(GdomeDOMString *s);
           /// @see Charset::transcode(GdomeDOMString *s);
           String& transcode(GdomeDOMString *s);
           /// @see Charset::transcode_cstr(const char *buf, size_t buf_size=0);
           xmlChar *transcode_buf2xchar(const char *buf, size_t buf_size=0);
           /// @see Charset::transcode(const String& s)
           GdomeDOMString_auto_ptr transcode(const String& s);
   
   #endif
   
 private:  private:
   
         void *fstorage;          void *fstorage;
         void *fcontext;          void *fcontext;
         void *ftag;          Charset *source_charset;
           Charset *client_charset;
   
 private: // implementation defined  private: 
           
     void *real_malloc(size_t size);          //{
           /// @name implementation defined
       void *real_malloc(size_t size, int place);
     void *real_calloc(size_t size);      void *real_calloc(size_t size);
           bool real_register_cleanup(void (*cleanup) (void *), void *data);
           //}
   
 private:   private: 
   
         /// checks whether mem allocated OK. throws exception otherwise          /// checks whether mem allocated OK. throws exception otherwise
         void *check(void *ptr, size_t size) {          void *check(void *ptr, size_t size) {
                 if(ptr)                  if(ptr) {
                           ftotal_allocated+=size;
                           ftotal_times++;
                         return ptr;                          return ptr;
                   }
   
                 fail(size);                  fail_alloc(size);
   
                 // never reached                  // never reached
                 return 0;                  return 0;
         }          }
         /// throws proper exception          /// throws allocation exception
         void fail(size_t size) const;          void fail_alloc(size_t size) const;
   
 private: // exception handling          /// throws register cleanup exception
           void fail_register_cleanup() const;
   
         // exception replacement mechanism is 'private'zed from direct usage  private: // statistics
         // Temp_exception object enforces paired set/restore          
         Exception *set_exception(Exception *e){          size_t ftotal_allocated;
                 Exception *r=fexception;          unsigned int ftotal_times;
                 fexception=e;  
                 return r;  
         }  
         void restore_exception(Exception *e) {  
                 fexception=e;  
         }  
   
 private:  
   
         // current request's exception object  
         Exception *fexception;  
   
 private: //disabled  private: //disabled
   
         // Pool(const Pool&) {}          Pool(const Pool&);
         Pool& operator = (const Pool&) { return *this; }          Pool& operator= (const Pool&);
 };  };
   
 /**   /** 
Line 105  private: //disabled Line 141  private: //disabled
   
         Holds Pool object. Contains useful wrappers to it's methods.          Holds Pool object. Contains useful wrappers to it's methods.
   
         @see NEW, Temp_exception          @see NEW
 */  */
   
   // all classes that are members parents of packed class [String] 
   // sould be packed also to avoid sparc odd st/lduh problem
   #include "pa_pragma_pack_begin.h"
 class Pooled {  class Pooled {
         // the pool i'm allocated on          // the pool i'm allocated on
         Pool& fpool;          Pool *fpool;
 public:  public:
   
         /// the Pooled-sole: Pooled instances can be allocated in Pool rather then on heap          /// the Pooled-sole: Pooled instances can be allocated in Pool rather then on heap
         static void *operator new(size_t size, Pool& apool) {           static void *operator new(size_t size, Pool& apool) { 
                 return apool.malloc(size);                  return apool.malloc(size, 1);
         }          }
   
         Pooled(Pool& apool) : fpool(apool) {          Pooled(Pool& apool) : fpool(&apool) {}
         }  
   
         /// my pool          /// my pool
         Pool& pool() const { return fpool; }          Pool& pool() const { return *fpool; }
   
         /// useful wrapper around pool  
         void *malloc(size_t size) const { return fpool.malloc(size); }  
         /// useful wrapper around pool  
         void *calloc(size_t size) const { return fpool.calloc(size); }  
         /// useful wrapper around pool  
         Exception& exception() const { return fpool.exception(); }  
 };  
 /// useful macro for creating objects on current Pooled object Pooled::pool()  
 #define NEW new(pool())  
   
 /**           /** used for moving objects from one pool to another. 
         Auto-object used for temporary changing Pool's exception().                  in between object can have no pool and can not be used
                   @see SQL_Driver_manager
           */
           void set_pool(Pool *apool) { fpool=apool; }
   
           //{
           /// @name useful wrapper around pool
           void *malloc(size_t size, int place=0) const { return fpool->malloc(size, place); }
           void *calloc(size_t size) const { return fpool->calloc(size); }
           void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
   #ifdef XML
   
         Use by with these macros:          const char *transcode_cstr(GdomeDOMString *s) { return fpool->transcode_cstr(s); }
         @code          String& transcode(GdomeDOMString *s) { return fpool->transcode(s); }
                 TRY {   
                         // ...   
                         if(?)   
                                 THROW(?);   
                         // ...  
                 } CATCH(e) {   
                         // code, using e fields  
                         // e.comment()   
                 }  
                 END_CATCH  
         @endcode  
   
         @see TRY, THROW  #endif
 */          //}
 class Temp_exception {  
         Pool& fpool;  
         Exception *saved_exception;  
 public:  
         Temp_exception(Pool& apool, Exception& exception) :   
                 fpool(apool),  
                 saved_exception(apool.set_exception(&exception)) {  
         }  
         ~Temp_exception() {   
                 fpool.restore_exception(saved_exception);   
         }  
 };  };
   #include "pa_pragma_pack_end.h"
 #define XTRY(pool) \  /// useful macro for creating objects on current Pooled object Pooled::pool()
         { \  #define NEW new(pool())
                 Exception temp_exception; \  
                 Temp_exception le(pool, temp_exception); \  
                 if(setjmp(temp_exception.mark)==0)  
   
 #define XTHROW(exception) exception._throw  
 #define XCATCH(e) \  
                 else{ \  
                         Exception& e=temp_exception;  
   
 #define XEND_CATCH \  
                 } \  
         }  
   
 //@{  
 /// @see Temp_exception   
 #define TRY XTRY(pool())  
 #define THROW XTHROW(exception())  
 #define CATCH(e) XCATCH(e)  
 #define END_CATCH XEND_CATCH   
   
 #define PTRY XTRY(pool)  
 #define PTHROW XTHROW(pool.exception())  
 #define PCATCH(e) XCATCH(e)  
 #define PEND_CATCH XEND_CATCH   
   
 #define RTHROW XTHROW(r.pool().exception())  
 //@}  
   
 #endif  #endif
Removed from v.1.45  
changed lines
  Added in v.1.81

E-mail: