--- parser3/src/include/pa_pool.h 2003/01/31 12:10:44 1.86.2.21 +++ parser3/src/include/pa_pool.h 2003/03/17 14:48:05 1.86.4.1 @@ -1,5 +1,5 @@ /** @file - Parser: Parser: reference counting classes decls. + Parser: pool class decl. Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com) @@ -9,9 +9,7 @@ #ifndef PA_POOL_H #define PA_POOL_H -static const char* IDENT_POOL_H="$Date: 2003/01/31 12:10:44 $"; - -// include +static const char* IDENT_POOL_H="$Date: 2003/03/17 14:48:05 $"; #include "pa_config_includes.h" @@ -23,27 +21,27 @@ static const char* IDENT_POOL_H="$Date: // 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 String; class Charset; class GdomeDOMString_auto_ptr; -/* * +/** Pool mechanizm allows users not to free up allocated memory, leaving that problem to 'pools'. @see Pooled -* / +*/ class Pool { public: Pool(void *astorage); + ~Pool(); + + //{@ collector issues + void collect_garbage(); + //}@ //{@ statistics size_t total_allocated() { return ftotal_allocated; } @@ -54,6 +52,11 @@ public: void *get_context() { return fcontext; } /// allocates some bytes on pool + void *malloc_atomic(size_t size, int place=0) { + return check(real_malloc_atomic(size, place), size); + } + + /// allocates some bytes on pool void *malloc(size_t size, int place=0) { return check(real_malloc(size, place), size); } @@ -63,7 +66,7 @@ public: } /// registers a routine to clean up non-pooled allocations - void register_cleanup(void (*cleanup) (void *), void *data) { + void register_cleanup(void (*cleanup) (void *, void *), void *data) { if(!real_register_cleanup(cleanup, data)) fail_register_cleanup(); } @@ -119,9 +122,12 @@ private: //{ /// @name implementation defined + void real_init(); + void real_finit(); void *real_malloc(size_t size, int place); + void *real_malloc_atomic(size_t size, int place); void *real_calloc(size_t size); - bool real_register_cleanup(void (*cleanup) (void *), void *data); + bool real_register_cleanup(void (*cleanup) (void *,void *), void *data); //} private: @@ -155,8 +161,6 @@ private: //disabled Pool(const Pool&); Pool& operator= (const Pool&); }; -*/ - /** Base for all classes that are allocated in 'pools'. @@ -164,11 +168,14 @@ private: //disabled Holds Pool object. Contains useful wrappers to it's methods. @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" +/** + @todo: try to remember the meaning of this old comment: + all classes that are members parents of packed class [String] + sould be packed also to avoid sparc odd st/lduh problem + [packing is unacceptable for garbage collector] +*/ class Pooled { // the pool i'm allocated on Pool *fpool; @@ -187,14 +194,15 @@ public: /** used for moving objects from one pool to another. 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 *malloc_atomic(size_t size, int place=0) const { return fpool->malloc_atomic(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); } + void register_cleanup(void (*cleanup) (void *, 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 @@ -215,168 +223,8 @@ public: #endif //} }; -#include "pa_pragma_pack_end.h" + /// useful macro for creating objects on current Pooled object Pooled::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 class object_ptr { - T *ptr; -public: - typedef T element_type; - - explicit object_ptr(T *ptr = 0) { - this->ptr=ptr; - if(ptr) - ptr->ref(); - } - template object_ptr(const object_ptr& src) { - this->ptr=src.get(); - } - object_ptr(const object_ptr& src) { - ptr=src.get(); - ptr->ref(); - } - object_ptr(T *ptr, int) { - this->ptr=ptr; - } - object_ptr& operator=(const object_ptr& 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; - } - operator !() const { - return get()==0; - } -}; - -#define DECLARE_OBJECT_PTR(name) \ - typedef object_ptr name##Ptr - -// typedef object_ptr name##Ptr; \ -// const object_ptr name##PtrZero(0); - -/// TEMPLATE CLASS smart_ptr, stolen from stl:auto_ptr -template - class smart_ptr { -public: - typedef T element_type; - explicit smart_ptr(T *_P = 0) - : _Owns(_P != 0), _Ptr(_P) {} - smart_ptr(const smart_ptr& _Y) - : _Owns(_Y._Owns), _Ptr(_Y.release()) {} - smart_ptr& operator=(const smart_ptr& _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); } - ~smart_ptr() - {if (_Owns) - delete _Ptr; } - T& operator*() const - {return (*get()); } - T *get() const - {return (_Ptr); } - T *release() const - {((smart_ptr *)this)->_Owns = false; - return (_Ptr); } - // so one could smart_ptr = smart_ptr - operator smart_ptr() const { - return *this; - } - operator bool() const { - return get()!=0; - } - operator T*() const { - return _Ptr; - } -private: - bool _Owns; - T *_Ptr; - }; - -// convinient types - -typedef smart_ptr CharPtr; -const CharPtr CharPtrZero(0); #endif