[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.77 and 1.86.2.2

version 1.77, 2002/02/08 07:27:44 version 1.86.2.2, 2003/01/23 11:37:55
Line 1 Line 1
 /** @file  /** @file
         Parser: pool class decl.          Parser: Parser: reference counting classes decls.
   
         Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
   
         Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$  
 */  */
   
 #ifndef PA_POOL_H  #ifndef PA_POOL_H
 #define PA_POOL_H  #define PA_POOL_H
   
   static const char* IDENT_POOL_H="$Date$";
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
 #ifdef XML  #ifdef XML
Line 19 Line 19
 #       include "libxml/tree.h"  #       include "libxml/tree.h"
 #endif  #endif
   
   void *pa_malloc(size_t size);
   void *pa_calloc(size_t size);
   void pa_free(void *ptr);
   void *pa_realloc(void *ptr, size_t size);
   
 // forwards  // forwards
   
 class Exception;  class Exception;
Line 26  class String; Line 31  class String;
 class Charset;  class Charset;
 class GdomeDOMString_auto_ptr;  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'.
   
         @see Pooled          @see Pooled
 */  * /
   
 class Pool {  class Pool {
 public:  public:
   
         Pool(void *astorage);          Pool(void *astorage);
   
         ///{@ statistics          //{@ statistics
         size_t total_allocated() { return ftotal_allocated; }          size_t total_allocated() { return ftotal_allocated; }
         unsigned int total_times() { return ftotal_times; }          unsigned int total_times() { return ftotal_times; }
         ///}@          //}@
   
         void set_context(void *acontext) { fcontext=acontext; }          void set_context(void *acontext) { fcontext=acontext; }
         void *get_context() { return fcontext; }          void *get_context() { return fcontext; }
Line 61  public: Line 66  public:
                         fail_register_cleanup();                          fail_register_cleanup();
         }          }
   
         ///{@ source charset          //{@ helpers
           void *copy(const void *buf, const size_t size);
           char *copy(const char *cstr);
           //}@
   
           //{@ source charset
         void set_source_charset(Charset& acharset);          void set_source_charset(Charset& acharset);
         Charset& get_source_charset();          Charset& get_source_charset();
         ///}@          //}@
   
         ///{@ client charset          //{@ client charset
         void set_client_charset(Charset& charset);          void set_client_charset(Charset& charset);
         Charset& get_client_charset();          Charset& get_client_charset();
         ///}@          //}@
   
 #ifdef XML  #ifdef XML
   
         /// @see Charset::transcode_cstr(xmlChar *s);          /// @see Charset::transcode_cstr(xmlChar *s);
         const char *transcode_cstr(xmlChar *s);          const char *transcode_cstr(xmlChar *s);
         /// @see Charset::transcode(xmlChar *s);          /// @see Charset::transcode(xmlChar *s);
         String& transcode(xmlChar *s);          String& transcode(xmlChar *s
   #ifndef NO_STRING_ORIGIN
                   , const String *origin
   #endif
                   );
         /// @see Charset::transcode_cstr(GdomeDOMString *s);          /// @see Charset::transcode_cstr(GdomeDOMString *s);
         const char *transcode_cstr(GdomeDOMString *s);          const char *transcode_cstr(GdomeDOMString *s);
         /// @see Charset::transcode(GdomeDOMString *s);          /// @see Charset::transcode(GdomeDOMString *s);
         String& transcode(GdomeDOMString *s);          String& transcode(GdomeDOMString *s
   #ifndef NO_STRING_ORIGIN
                   , const String *origin
   #endif
                   );
           /// @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)          /// @see Charset::transcode(const String& s)
         GdomeDOMString_auto_ptr transcode(const String& s);          GdomeDOMString_auto_ptr transcode(const String& s);
   
Line 133  private: //disabled Line 153  private: //disabled
         Pool(const Pool&);          Pool(const Pool&);
         Pool& operator= (const Pool&);          Pool& operator= (const Pool&);
 };  };
   */
   
   
 /**   /** 
         Base for all classes that are allocated in 'pools'.          Base for all classes that are allocated in 'pools'.
Line 140  private: //disabled Line 162  private: //disabled
         Holds Pool object. Contains useful wrappers to it's methods.          Holds Pool object. Contains useful wrappers to it's methods.
   
         @see NEW          @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;
Line 159  public: Line 185  public:
         /** used for moving objects from one pool to another.           /** used for moving objects from one pool to another. 
                 in between object can have no pool and can not be used                  in between object can have no pool and can not be used
                 @see SQL_Driver_manager                  @see SQL_Driver_manager
         */          * /
         void set_pool(Pool *apool) { fpool=apool; }          void set_pool(Pool *apool) { fpool=apool; }
   
         //{          //{
Line 167  public: Line 193  public:
         void *malloc(size_t size, int place=0) const { return fpool->malloc(size, place); }          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 *calloc(size_t size) const { return fpool->calloc(size); }
         void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }          void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
           void *copy(const void *buf, const size_t size) { return fpool->copy(buf, size); }
           char *copy(const char *cstr) { return fpool->copy(cstr); }
 #ifdef XML  #ifdef XML
   
         const char *transcode_cstr(GdomeDOMString *s) { return fpool->transcode_cstr(s); }          const char *transcode_cstr(GdomeDOMString *s) { return fpool->transcode_cstr(s); }
         String& transcode(GdomeDOMString *s) { return fpool->transcode(s); }          String& transcode(GdomeDOMString *s
   #ifndef NO_STRING_ORIGIN
                   , const String *origin
   #endif
                   ) { 
                   return fpool->transcode(s
   #ifndef NO_STRING_ORIGIN
                           , origin
   #endif          
                           ); 
           }
   
 #endif  #endif
         //}          //}
 };  };
   #include "pa_pragma_pack_end.h"
 /// useful macro for creating objects on current Pooled object Pooled::pool()  /// useful macro for creating objects on current Pooled object Pooled::pool()
 #define NEW new(pool())  #define NEW new(pool())
   */
   
   #define override
   
   void *operator new(size_t size) { 
           return pa_malloc(size);
   }
   void operator delete(void *ptr) {
           pa_free(ptr);
   }
   
   class PA_Allocated {
   public:
           /// the sole: instances allocated using our functions
           static void *operator new(size_t size) { 
                   return pa_malloc(size);
           }
           static void operator delete(void *ptr) {
                   pa_free(ptr);
           }
   };
   
   /** 
           Base for all Parser classes, memory allocation/dallocation goes via pa_malloc/pa_free.
   */
   class PA_Object: public PA_Allocated {
           mutable unsigned long references;
   public:
           PA_Object(): references(0) {}
           virtual ~PA_Object()=0;
            
           void ref() {
                   references++;
           }
           void unref() {
                   if(references) {
                           if(--references==0)
                                   delete this;
                   }
           }
   };
   
   
   template<typename T> class object_auto_ptr {
           T *ptr;
   public:
           typedef T element_type;
   
           explicit object_auto_ptr(T *ptr = 0) {
                   this->ptr=ptr;
                   if(ptr)
                           ptr->ref();
           }
           object_auto_ptr(const object_auto_ptr<T>& src) {
                   ptr=src.get();
                   ptr->ref();
           }
       object_auto_ptr<T>& operator=(object_auto_ptr<T>& src) {
                   if(this!=&src)
                           if(ptr!=src.get()) {
                                   if(ptr)
                                           ptr->unref();
                                   ptr=src.get();
                                   if(ptr)
                                           ptr->ref();
                           }
           }
       ~object_auto_ptr() {
                   if(ptr)
                           ptr->unref();
           }
       T& operator*() const {
                   return *get();
           }
       T *operator->() const {
                   return get();
           }
       T *get() const {
                   return ptr;
           }
   };
   
   /// TEMPLATE CLASS simple_auto_ptr, stolen from stl:auto_ptr
   template<class T>
           class simple_auto_ptr {
   public:
           typedef T element_type;
           explicit simple_auto_ptr(T *_P = 0)
                   : _Owns(_P != 0), _Ptr(_P) {}
           simple_auto_ptr(const simple_auto_ptr<T>& _Y)
                   : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
           simple_auto_ptr<T>& operator=(const simple_auto_ptr<T>& _Y)
                   {if (this != &_Y)
                           {if (_Ptr != _Y.get())
                                   {if (_Owns)
                                           delete _Ptr;
                                   _Owns = _Y._Owns; }
                           else if (_Y._Owns)
                                   _Owns = true;
                           _Ptr = _Y.release(); }
                   return (*this); }
           ~simple_auto_ptr()
                   {if (_Owns)
                           delete _Ptr; }
           T& operator*() const
                   {return (*get()); }
           T *operator->() const
                   {return (get()); }
           T *get() const
                   {return (_Ptr); }
           T *release() const
                   {((simple_auto_ptr<T> *)this)->_Owns = false;
                   return (_Ptr); }
   private:
           bool _Owns;
           T *_Ptr;
           };
   
   
 #endif  #endif
Removed from v.1.77  
changed lines
  Added in v.1.86.2.2

E-mail: