[BACK]Return to pa_array.h CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_array.h between versions 1.19 and 1.40

version 1.19, 2001/02/22 15:17:39 version 1.40, 2001/05/16 16:54:00
Line 1 Line 1
 /*  /** @file
   $Id$          Parser: array class decl.
 */  
   
 /*          Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
   
         Array               Chunk0          Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
         ======              ========  
         head--------------->[ptr]  
         append_here-------->[ptr]  
         link_row            ........  
                         .                       .  
                         .                       [ptr]  
                         ...........>[link to the next chunk]  
   
           $Id$
 */  */
   
 #ifndef PA_ARRAY_H  #ifndef PA_ARRAY_H
Line 24 Line 17
 #include "pa_types.h"  #include "pa_types.h"
 #include "pa_string.h"  #include "pa_string.h"
   
   /**     
           Pooled Array.
   
           Internal structure:
           @verbatim
                   Array               Chunk0
                   ======              ========
                   head--------------->[ptr]
                   append_here-------->[ptr]
                   link_row            ........
                                   .                       .
                                   .                       [ptr]
                                   ...........>[link to the next chunk]
           @endverbatim
   */
   
 class Array : public Pooled {  class Array : public Pooled {
 public:  public:
   
           /// Array item type
         typedef void Item;          typedef void Item;
   
           /*/// for_each iterator function type, const info
           typedef void (*For_each_func_const)(Item *value, const void *info);
           */
   
           /// for_each iterator function type
           typedef void (*For_each_func)(Item *value, void *info);
   
           /// first_that iterator function type, const info
           typedef bool (*First_that_func_const)(Item *value, const void *info);
   
           /// first_that iterator function type
           typedef bool (*First_that_func)(Item *value, void *info);
   
         enum {          enum {
                 CR_INITIAL_ROWS_DEFAULT=10,                  CR_INITIAL_ROWS_DEFAULT=3, ///< default preallocated row count
                 CR_GROW_PERCENT=60                  CR_GROW_COUNT=3 ///< each time the Array chunk_is_full() array expanded()
         };          };
   
 public:  public:
   
         Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT);          Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT);
   
         int size() const {           /**
                 // for get and quick_get                  size Array. how many items are in it. 
                   must be used with quick_get like this:
                   @code
                           int size=src.quick_size();
                           for(int i=0; i<size; i++) {
                                   z=src.quick_get(i);
                           }
                   @endcode
           */
           int quick_size() const { 
                   // for quick_get
                 cache_chunk_base=0;                  cache_chunk_base=0;
                 cache_chunk=head;                  cache_chunk=head;
                 return fused_rows;                   return size(); 
         }          }
           /// size Array. how many items are in it
           int size() const { return fused_rows; }
           /// append Item to array
         Array& operator += (Item *src);          Array& operator += (Item *src);
           /// append int value to array
           Array& operator += (int value) { return *this+=reinterpret_cast<Item *>(value); }
   
           /// dirty hack to allow constant items storage. I long for Array<const Item*>
           Array& operator += (const Item *src) { return *this+=const_cast<Item *>(src); }
   
           /// append other Array portion to this one. starting from offset
         Array& append_array(const Array& src, int offset=0);          Array& append_array(const Array& src, int offset=0);
         Item *quick_get(int index) const {  
                 // considering these true:  
                 //   index increments from 0 to size()-1  
                 //   index>=0 && index<size()  
                 //   index>=cache_chunk_base  
   
           /** 
                   quickly gets some item considering...
   
                   these true:
                           - index increments from 0 to size()-1
                           - index>=0 && index<size()
                           - index>=cache_chunk_base
           */
           Item *quick_get(int index) const {
                 // next chunk will be with "index" row                  // next chunk will be with "index" row
                 if(!(index<cache_chunk_base+cache_chunk->count)) {                  if(!(index<cache_chunk_base+cache_chunk->count)) {
                         int count=cache_chunk->count;                          int count=cache_chunk->count;
Line 63  public: Line 110  public:
         }          }
   
         Item *get(int index) const;          Item *get(int index) const;
           int get_int(int index) const { return reinterpret_cast<int>(get(index)); }
   
         void put(int index, Item *item);          void put(int index, Item *item);
         const char *get_cstr(int index) const {           /// convinient way to get strings from Array. I long for Array<const String *>
                 return static_cast<const char *>(get(index));   
         }  
         const String *get_string(int index) const {           const String *get_string(int index) const { 
                 return static_cast<const String *>(get(index));                   return const_cast<const String *>(static_cast<String *>(get(index))); 
         }          }
           const String *quick_get_string(int index) const { 
                   return const_cast<const String *>(static_cast<String *>(quick_get(index))); 
           }
   
           /*/// iterate over all elements, const info
           void for_each(For_each_func_const func, const void *info=0) const;
           /*/
   
           /// iterate over all elements
           void for_each(For_each_func func, void *info=0) const;
   
           /// iterate over all elements until condition, const info
           void* first_that(First_that_func_const func, const void *info=0) const;
   
           /// iterate over all elements until condition
           void* first_that(First_that_func func, void *info=0) const;
   
 private:  private:
   
           /// several record elements
         struct Chunk {          struct Chunk {
                 // the number of rows in chunk                  int count;  ///< the number of rows in chunk
                 int count;                  /// item or a link to next chunk union
                 union Row {                  union Row {
                         Item *item;                          Item *item;
                         Chunk *link;  // link to the next chunk in chain                          Chunk *link;  ///< link to the next chunk in chain
                 } rows[1];                  } rows[1];
                 // next rows are here                  // next rows are here
         }          }
                 *head;  // the head chunk of the chunk chain                  *head;  ///< the head chunk of the chunk chain
   
         // last allocated chunk          /** last allocated chunk
         // helps appending Arrays                  helps appending Arrays
           */
         Chunk *tail;          Chunk *tail;
   
         // next append would write to this record          /// next append would write to this record
         Chunk::Row *append_here;          Chunk::Row *append_here;
                   
         // the address of place where lies address           /**     the address of place where lies address 
         // of the link to the next chunk to allocate                  of the link to the next chunk to allocate
           */
         Chunk::Row *link_row;          Chunk::Row *link_row;
   
 private:  private:
Removed from v.1.19  
changed lines
  Added in v.1.40

E-mail: