[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.52 and 1.55

version 1.52, 2001/05/17 10:22:24 version 1.55, 2001/09/20 14:25:06
Line 13 Line 13
   
 #include "pa_config_includes.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;
   
   void Pool_cleanup(void *);
   
 /**   /** 
         Pool mechanizm allows users not to free up allocated memory,          Pool mechanizm allows users not to free up allocated memory,
Line 28  class Temp_exception; Line 38  class Temp_exception;
   
 class Pool {  class Pool {
         friend Temp_exception;          friend Temp_exception;
           friend void Pool_cleanup(void *);
 public:  public:
   
         Pool(void *astorage) : fstorage(astorage), fcontext(0), ftag(0), fexception(0) {}          Pool(void *astorage);
   
   private:
           void cleanup() {
                   delete transcoder;
           }
   public:
         void set_context(void *acontext) { fcontext=acontext; }          void set_context(void *acontext) { fcontext=acontext; }
         void *context() { return fcontext; }          void *context() { return fcontext; }
   
         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 63  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);
           /// converts Xalan string to char *
           const char *transcode(const XalanDOMString& s);
           /// converts XSL exception to parser exception
           void _throw(const String *source, const XSLException& e);
   
   private:
   
           void set_charset(const char *charset);
           void update_transcoder();
   
 private:  private:
   
         void *fstorage;          void *fstorage;
         void *fcontext;          void *fcontext;
         void *ftag;          void *ftag;
           const char *charset;
           XMLTranscoder *transcoder;
   
 private:   private: 
                   
Line 62  private: Line 98  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 108  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 136  public: Line 176  public:
         /// useful wrapper around pool          /// 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          /// useful wrapper around pool
           void register_cleanup(void (*cleanup) (void *), void *data) { 
                   fpool->register_cleanup(cleanup, data);
           }
           /// useful wrapper around pool
         Exception& exception() const { return fpool->exception(); }          Exception& exception() const { return fpool->exception(); }
           /// useful wrapper around pool
           const char *transcode(const XalanDOMString& s) { return fpool->transcode(s); }
           /// useful wrapper around pool
           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.52  
changed lines
  Added in v.1.55

E-mail: