[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.51 and 1.58

version 1.51, 2001/05/16 17:10:34 version 1.58, 2001/09/21 08:41:28
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"
   
   #include <XalanDOM/XalanDOMString.hpp>
   #include <util/TransService.hpp>
   #include <PlatformSupport/XSLException.hpp>
   
   
   // forwards
   
 class Exception;  class Exception;
 class Temp_exception;  class Temp_exception;
   class String;
   
 /**   /** 
         Pool mechanizm allows users not to free up allocated memory,          Pool mechanizm allows users not to free up allocated memory,
Line 30  class Pool { Line 38  class Pool {
         friend Temp_exception;          friend Temp_exception;
 public:  public:
   
         Pool(void *astorage) : fstorage(astorage), fcontext(0), ftag(0), fexception(0) {}          Pool(void *astorage);
           ~Pool();
   
         void set_context(void *acontext) { fcontext=acontext; }          void set_context(void *acontext) { fcontext=acontext; }
         void *context() { return fcontext; }          void *context() { return fcontext; }
Line 38  public: Line 47  public:
         void set_tag(void *atag) { ftag=atag; }          void set_tag(void *atag) { ftag=atag; }
         void *tag() { return ftag; }          void *tag() { return ftag; }
   
         /// current exception object of the pool  
         Exception& exception() const { return *fexception; }  
   
         /// allocates some bytes on pool          /// allocates some bytes on pool
         void *malloc(size_t size/*, int place=0*/) {          void *malloc(size_t size/*, int place=0*/) {
                 return check(real_malloc(size/*, place*/), size);                  return check(real_malloc(size/*, place*/), size);
Line 50  public: Line 56  public:
                 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();
           }
   
           /// current exception object of the pool
           Exception& exception() const { return *fexception; }
   
           /// resets transcoder if they change charset 
           void set_charset(const String &charset);
           /// returns current charset
           const String& get_charset() { return *charset; }
           /// converts Xalan string to char *
           const char *transcode_cstr(const XalanDOMString& s);
           /// converts Xalan string to parser String
           String& transcode(const XalanDOMString& s);
           /// converts XSL exception to parser exception
           void _throw(const String *source, const XSLException& e);
   
   private:
   
           void set_charset(const char *new_scharset);
           void update_transcoder();
   
 private:  private:
   
         void *fstorage;          void *fstorage;
         void *fcontext;          void *fcontext;
         void *ftag;          void *ftag;
           const String *charset;
           XMLTranscoder *transcoder;
   
 private:   private: 
                   
Line 62  private: Line 95  private:
         /// @name implementation defined          /// @name implementation defined
     void *real_malloc(size_t size/*, int place*/);      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: 
Line 71  private: Line 105  private:
                 if(ptr)                  if(ptr)
                         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;
   
           /// throws register cleanup exception
           void fail_register_cleanup() const;
   
 private: // exception handling  private: // exception handling
   
Line 131  public: Line 168  public:
         */          */
         void set_pool(Pool *apool) { fpool=apool; }          void set_pool(Pool *apool) { fpool=apool; }
   
         /// useful wrapper around pool          //{
           /// @name useful wrapper around pool
         void *malloc(size_t size) const { return fpool->malloc(size); }          void *malloc(size_t size) const { return fpool->malloc(size); }
         /// useful wrapper around pool  
         void *calloc(size_t size) const { return fpool->calloc(size); }          void *calloc(size_t size) const { return fpool->calloc(size); }
         /// useful wrapper around pool          void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
         Exception& exception() const { return fpool->exception(); }          Exception& exception() const { return fpool->exception(); }
           const char *transcode_cstr(const XalanDOMString& s) { return fpool->transcode_cstr(s); }
           String& transcode(const XalanDOMString& s) { return fpool->transcode(s); }
           void _throw(const String *source, const XSLException& e) { fpool->_throw(source, e); }
           //}
 };  };
 /// 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())
Removed from v.1.51  
changed lines
  Added in v.1.58

E-mail: