[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.82 and 1.86.2.27

version 1.82, 2002/08/01 11:26:47 version 1.86.2.27, 2003/02/04 09:44:27
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: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
Line 9 Line 9
 #ifndef PA_POOL_H  #ifndef PA_POOL_H
 #define PA_POOL_H  #define PA_POOL_H
   
 static const char* IDENT_POOL_H="$Id$";  static const char* IDENT_POOL_H="$Date$";
   
   // include
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
Line 21  static const char* IDENT_POOL_H="$Id$"; Line 23  static const char* IDENT_POOL_H="$Id$";
   
 // forwards  // forwards
   
   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);
   
 class Exception;  class Exception;
 class String;  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:
Line 61  public: Line 68  public:
                         fail_register_cleanup();                          fail_register_cleanup();
         }          }
   
           //{@ helpers
           void *copy(const void *buf, const size_t size);
           char *copy(const char* cstr);
           //}@
   
         //{@ source charset          //{@ source charset
         void set_source_charset(Charset& acharset);          void set_source_charset(Charset& acharset);
         Charset& get_source_charset();          Charset& get_source_charset();
Line 74  public: Line 86  public:
 #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
         /// @see Charset::transcode_cstr(const char *buf, size_t buf_size=0);  #ifndef NO_STRING_ORIGIN
         xmlChar *transcode_buf2xchar(const char *buf, size_t buf_size=0);                  , 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 135  private: //disabled Line 155  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 142  private: //disabled Line 164  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]   // all classes that are members parents of packed class [String] 
 // sould be packed also to avoid sparc odd st/lduh problem  // sould be packed also to avoid sparc odd st/lduh problem
Line 165  public: Line 187  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 173  public: Line 195  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
         //}          //}
Line 184  public: Line 218  public:
 #include "pa_pragma_pack_end.h"  #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
   #define rethrow throw
   
   inline void *operator new[] (size_t size) {
           return pa_malloc(size);
   }
   inline 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);
           }
           static void *malloc(size_t size) {
                   return pa_malloc(size);
           }
           static void *calloc(size_t size) {
                   return pa_calloc(size);
           }
           static void *realloc(void *ptr, size_t size) {
                   return pa_realloc(ptr, size);
           }
   
   };
   
   /** 
           Base for all Parser classes, memory allocation/dallocation goes via pa_malloc/pa_free.
   */
   class PA_Object: public PA_Allocated {
           mutable unsigned long freferences;
   public:
           PA_Object(): freferences(0) {}
           virtual ~PA_Object()=0;
            
           void ref() const {
                   freferences++;
           }
           void unref() const {
                   if(freferences) {
                           if(--freferences==0)
                                   delete this;
                   }
           }
   };
   
   
   template<typename T> class object_ptr {
           T *ptr;
   public:
           typedef T element_type;
   
           explicit object_ptr(T *ptr = 0) {
                   this->ptr=ptr;
                   if(ptr)
                           ptr->ref();
           }
           template<class B> object_ptr(const object_ptr<B>& src) {
                   this->ptr=src.get();
                   if(ptr)
                           ptr->ref();
           }
           object_ptr(const object_ptr<T>& src) {
                   ptr=src.get();
                   ptr->ref();
           }
           object_ptr(T *ptr, int) {
                   this->ptr=ptr;
           }
      object_ptr<T>& operator=(const object_ptr<T>& src) {
                   if(this!=&src)
                           if(ptr!=src.get()) {
                                   if(ptr)
                                           ptr->unref();
                                   ptr=src.get();
                                   if(ptr)
                                           ptr->ref();
                           }
                   return *this;
           }
       ~object_ptr() {
                   if(ptr)
                           ptr->unref();
           }
       T& operator*() const {
                   return *get();
           }
       T *operator->() const {
                   return get();
           }
       T *get() const {
                   return ptr;
           }
           operator bool() const {
                   return get()!=0;
           }
           bool operator !() const {
                   return get()==0;
           }
   };
   
   #define DECLARE_OBJECT_PTR(name) \
           typedef object_ptr<name> name##Ptr
   
   //      typedef object_ptr<name> name##Ptr; \
   //      const object_ptr<name> name##PtrZero(0);
   
   /// TEMPLATE CLASS smart_ptr, stolen  from stl:auto_ptr & renamed field/params [not compiled on gcc]
   template<class T>
           class smart_ptr {
           bool owns;
           T *ptr;
   public:
           typedef T element_type;
           explicit smart_ptr(T *aptr = 0)
                   : owns(aptr != 0), ptr(aptr) {}
           smart_ptr(const smart_ptr<T>& src)
                   : owns(src.owns), ptr(src.release()) {}
           smart_ptr<T>& operator=(const smart_ptr<T>& src)
                   {if (this != &src)
                           {if (ptr != src.get())
                                   {if (owns)
                                           delete ptr;
                                   owns = src.owns; }
                           else if (src.owns)
                                   owns = true;
                           ptr = src.release(); }
                   return (*this); }
           ~smart_ptr()
                   {if (owns)
                           delete ptr; }
           T& operator*() const
                   {return (*get()); }
           T *get() const
                   {return ptr; }
           T *release() const
                   {((smart_ptr<T> *)this)->owns = false;
                   return (ptr); }
           operator bool() const {
                   return get()!=0;
           }
           operator T*() const {
                   return ptr;
           }
           };
   
   // convinient types
   
   typedef smart_ptr<char> CharPtr;
   const CharPtr CharPtrZero(0);
   
 #endif  #endif
Removed from v.1.82  
changed lines
  Added in v.1.86.2.27

E-mail: