Return to pa_pool.h CVS log

Up to [parser3project] / parser3 / src / include

Annotation of parser3/src/include/pa_pool.h, revision 1.1.1.1

1.1       paf         1: /*
                      2: 
                      3:        String                          Chunk0
                      4:        ======                          ========
                      5:        head_chunk--------->[ptr, size]
                      6:        append_here-------->[ptr, size]
                      7:        chunk_link_row      ........
                      8:                        .                       .
                      9:                        .                       [ptr, size]
                     10:                        ...........>[link to the next chunk]
                     11: 
                     12: */
                     13: 
                     14: #ifndef PA_POOL_H
                     15: #define PA_POOL_H
                     16: 
                     17: #include <stddef.h>
                     18: 
                     19: class Pool;
                     20: 
                     21: class String {
                     22:        friend Pool;
                     23: 
                     24:        // the pool I'm allocated on
                     25:        Pool *pool;
                     26: 
                     27:        // the number of records per chunk
                     28:        int chunk_items;
                     29:        enum {
                     30:                CI_CONST_STRING_GROW=5,
                     31:                CI_DYNAMIC_STRING_GROW_DEFAULT=10
                     32:        };
                     33: 
                     34:        struct Chunk {
                     35:                union Row {
                     36:                        // chunk item
                     37:                        struct {
                     38:                                char *ptr;  // pointer to the start of string fragment
                     39:                                size_t size;  // length of the fragment
                     40:                        } item;
                     41:                        Chunk *link;  // link to the next chunk in chain
                     42:                } first;
                     43:                // next rows are here
                     44:        }
                     45:                *head_chunk;  // the head chunk of the chunk chain
                     46: 
                     47:        // next append would write to this record
                     48:        Chunk::Row *append_here;
                     49:        
                     50:        // the address of place where lies address 
                     51:        // of the link to the next chunk to allocate
                     52:        Chunk::Row *chunk_link_row;
                     53: 
                     54:        // new&constructors made private to enforce factory manufacturing at pool
                     55:        void *operator new(size_t size, Pool *apool);
                     56: 
                     57:        void construct(Pool *apool, int achunk_items);
                     58:        String(Pool *apool, int achunk_items=CI_DYNAMIC_STRING_GROW_DEFAULT) { 
                     59:                construct(apool, achunk_items); 
                     60:        }
                     61:        String(Pool *apool, char *src) {
                     62:                construct(apool, CI_CONST_STRING_GROW);
                     63:                *this+=src;
                     64:        }
                     65: 
                     66:        bool chunk_is_full() {
                     67:                return append_here == chunk_link_row;
                     68:        }
                     69:        void expand();
                     70: 
                     71: public:
                     72: 
                     73:        size_t size();
                     74:        char *c_str();
                     75:        String& operator += (char *src);
                     76: };
                     77: 
                     78: class Pool {
                     79: public:
                     80:        Pool();
                     81:        ~Pool();
                     82:     void *alloc(size_t size);
                     83:     void *calloc(size_t size);
                     84: 
                     85:        String *makeString() { 
                     86:                return new(this) String(this);
                     87:        }
                     88:        String *makeString(int chunk_items) {
                     89:                return new(this) String(this, chunk_items);
                     90:        }
                     91:        String *makeString(char *src) {
                     92:                return new(this) String(this, src);
                     93:        }
                     94: };
                     95: 
                     96: #endif