Annotation of parser3/src/include/pa_pool.h, revision 1.66
1.34 paf 1: /** @file
1.36 paf 2: Parser: pool class decl.
3:
1.27 paf 4: Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
1.36 paf 5:
1.28 paf 6: Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
1.27 paf 7:
1.66 ! parser 8: $Id: pa_pool.h,v 1.65 2001/10/19 14:42:53 parser Exp $
1.1 paf 9: */
10:
11: #ifndef PA_POOL_H
12: #define PA_POOL_H
13:
1.52 parser 14: #include "pa_config_includes.h"
1.1 paf 15:
1.59 parser 16: #ifdef XML
1.66 ! parser 17: #include <memory>
1.55 parser 18: #include <XalanDOM/XalanDOMString.hpp>
19: #include <util/TransService.hpp>
1.59 parser 20: #endif
1.55 parser 21:
22: // forwards
23:
1.21 paf 24: class Exception;
1.25 paf 25: class Temp_exception;
1.55 parser 26: class String;
27:
1.35 paf 28: /**
1.34 paf 29: Pool mechanizm allows users not to free up allocated memory,
30: leaving that problem to 'pools'.
31:
1.38 paf 32: @see Pooled
1.34 paf 33: */
1.47 paf 34:
1.1 paf 35: class Pool {
36: public:
1.18 paf 37:
1.55 parser 38: Pool(void *astorage);
1.56 parser 39: ~Pool();
1.18 paf 40:
1.40 paf 41: void set_context(void *acontext) { fcontext=acontext; }
1.64 parser 42: void *get_context() { return fcontext; }
1.39 paf 43:
1.47 paf 44: void set_tag(void *atag) { ftag=atag; }
45: void *tag() { return ftag; }
1.44 paf 46:
1.34 paf 47: /// allocates some bytes on pool
1.51 parser 48: void *malloc(size_t size/*, int place=0*/) {
49: return check(real_malloc(size/*, place*/), size);
1.18 paf 50: }
1.34 paf 51: /// allocates some bytes clearing them with zeros
1.18 paf 52: void *calloc(size_t size) {
53: return check(real_calloc(size), size);
54: }
1.39 paf 55:
1.53 parser 56: /// registers a routine to clean up non-pooled allocations
1.54 parser 57: void register_cleanup(void (*cleanup) (void *), void *data) {
58: if(!real_register_cleanup(cleanup, data))
59: fail_register_cleanup();
60: }
1.53 parser 61:
1.60 parser 62: /// resets transcoder if they change charset
63: void set_charset(const String &charset);
64: /// returns current charset
65: const String& get_charset() { return *charset; }
66:
1.39 paf 67: private:
68:
69: void *fstorage;
1.40 paf 70: void *fcontext;
1.47 paf 71: void *ftag;
1.60 parser 72: const String *charset;
1.8 paf 73:
1.50 parser 74: private:
75:
76: //{
77: /// @name implementation defined
1.51 parser 78: void *real_malloc(size_t size/*, int place*/);
1.20 paf 79: void *real_calloc(size_t size);
1.54 parser 80: bool real_register_cleanup(void (*cleanup) (void *), void *data);
1.50 parser 81: //}
1.17 paf 82:
1.23 paf 83: private:
1.17 paf 84:
1.34 paf 85: /// checks whether mem allocated OK. throws exception otherwise
1.23 paf 86: void *check(void *ptr, size_t size) {
87: if(ptr)
88: return ptr;
89:
1.54 parser 90: fail_alloc(size);
1.23 paf 91:
92: // never reached
93: return 0;
94: }
1.54 parser 95: /// throws allocation exception
96: void fail_alloc(size_t size) const;
97:
98: /// throws register cleanup exception
99: void fail_register_cleanup() const;
1.23 paf 100:
1.59 parser 101: #ifdef XML
102:
103: public:
104: /// converts Xalan string to char *
105: const char *transcode_cstr(const XalanDOMString& s);
106: /// converts Xalan string to parser String
107: String& transcode(const XalanDOMString& s);
1.63 parser 108: /// converts char * to Xalan string
1.65 parser 109: std::auto_ptr< XalanDOMString> transcode_buf(const char *buf, size_t buf_size);
1.63 parser 110: /// converts parser String to Xalan string
1.65 parser 111: std::auto_ptr<XalanDOMString> transcode(const String& s);
1.59 parser 112:
113: private:
114:
115: void set_charset(const char *new_scharset);
116: void update_transcoder();
117:
118: private:
119:
120: XMLTranscoder *transcoder;
121:
122: #endif
123:
1.8 paf 124: private: //disabled
125:
1.64 parser 126: Pool(const Pool&);
127: Pool& operator= (const Pool&);
1.21 paf 128: };
129:
1.35 paf 130: /**
1.34 paf 131: Base for all classes that are allocated in 'pools'.
132:
133: Holds Pool object. Contains useful wrappers to it's methods.
1.38 paf 134:
1.64 parser 135: @see NEW
1.34 paf 136: */
1.21 paf 137: class Pooled {
1.23 paf 138: // the pool i'm allocated on
1.49 paf 139: Pool *fpool;
1.21 paf 140: public:
1.37 paf 141:
142: /// the Pooled-sole: Pooled instances can be allocated in Pool rather then on heap
1.21 paf 143: static void *operator new(size_t size, Pool& apool) {
1.51 parser 144: return apool.malloc(size/*, 1*/);
1.21 paf 145: }
146:
1.49 paf 147: Pooled(Pool& apool) : fpool(&apool) {}
1.23 paf 148:
1.34 paf 149: /// my pool
1.49 paf 150: Pool& pool() const { return *fpool; }
151:
152: /** used for moving objects from one pool to another.
153: in between object can have no pool and can not be used
154: @see SQL_Driver_manager
155: */
156: void set_pool(Pool *apool) { fpool=apool; }
1.21 paf 157:
1.57 parser 158: //{
159: /// @name useful wrapper around pool
1.49 paf 160: void *malloc(size_t size) const { return fpool->malloc(size); }
161: void *calloc(size_t size) const { return fpool->calloc(size); }
1.57 parser 162: void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
1.59 parser 163: #ifdef XML
1.57 parser 164: const char *transcode_cstr(const XalanDOMString& s) { return fpool->transcode_cstr(s); }
165: String& transcode(const XalanDOMString& s) { return fpool->transcode(s); }
1.59 parser 166: #endif
1.57 parser 167: //}
1.23 paf 168: };
1.34 paf 169: /// useful macro for creating objects on current Pooled object Pooled::pool()
1.23 paf 170: #define NEW new(pool())
1.1 paf 171:
172: #endif
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_pool.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / include