--- parser3/src/include/pa_array.h 2001/03/19 17:42:12 1.26 +++ parser3/src/include/pa_array.h 2002/08/01 11:41:14 1.55 @@ -1,117 +1,141 @@ /** @file - Parser: array class decl. + Parser: Array & Array_iter classes decls. - Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) - - Author: Alexander Petrosyan (http://design.ru/paf) - - $Id: pa_array.h,v 1.26 2001/03/19 17:42:12 paf Exp $ + Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com) + Author: Alexandr Petrosian (http://paf.design.ru) */ #ifndef PA_ARRAY_H #define PA_ARRAY_H -#include +static const char* IDENT_ARRAY_Y="$Date: 2002/08/01 11:41:14 $"; #include "pa_pool.h" #include "pa_types.h" #include "pa_string.h" +class Array_iter; + /** Pooled Array. - Internal structure: @verbatim - - Array Chunk0 - ====== ======== - head--------------->[ptr] - append_here-------->[ptr] - link_row ........ - . . - . [ptr] - ...........>[link to the next chunk] - + Internal structure: + @verbatim + Array Chunk0 + ====== ======== + head--------------->[ptr] + append_here-------->[ptr] + link_row ........ + . . + . [ptr] + ...........>[link to the next chunk] @endverbatim */ class Array : public Pooled { + friend class Array_iter; public: - typedef void Item; ///< Array item type + /// Array item type + 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); + /* + /// for_each iterator function type, passing item storage address + typedef void (*For_each_func_storage)(Item ** value, void *info); + */ + + /// first_that iterator function type, const info + typedef void *(*Item_that_func_const)(Item *value, const void *info); + + /// first_that iterator function type + typedef void *(*Item_that_func)(Item *value, void *info); enum { - CR_INITIAL_ROWS_DEFAULT=10, ///< default preallocated row count - CR_GROW_PERCENT=60 ///< each time the Array chunk_is_full() array expanded() + CR_INITIAL_ROWS_DEFAULT=3, ///< default preallocated row count + CR_GROW_COUNT=3 ///< each time the Array chunk_is_full() array expanded() }; public: Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT); + Array(const Array& source, int offset=0); /// size Array. how many items are in it - int size() const { - // for get and quick_get - cache_chunk_base=0; - cache_chunk=head; - return fused_rows; - } + int size() const { return fused_rows; } /// append Item to array Array& operator += (Item *src); + /// append int value to array + Array& operator += (int value) { return *this+=reinterpret_cast(value); } /// dirty hack to allow constant items storage. I long for Array - Array& operator += (const Item *src) { return *this+=const_cast(src); } + Array& operator += (const Item *src) { return *this+=const_cast(src); } /// append other Array portion to this one. starting from offset Array& append_array(const Array& src, int offset=0); - /** - quickly gets some item considering... - - these true: - - index increments from 0 to size()-1 - - index>=0 && index=cache_chunk_base - */ - Item *quick_get(int index) const { - // next chunk will be with "index" row - if(!(indexcount)) { - int count=cache_chunk->count; - cache_chunk_base+=count; - cache_chunk=cache_chunk->rows[count].link; - } - - return cache_chunk->rows[index-cache_chunk_base].item; - } - Item *get(int index) const; + int get_int(int index) const { return reinterpret_cast(get(index)); } + void put(int index, Item *item); + void put_int(int index, int value) { put(index, reinterpret_cast(value)); } /// convinient way to get strings from Array. I long for Array const String *get_string(int index) const { - return static_cast(get(index)); + return const_cast(static_cast(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, passing address of item storage + void for_each(For_each_func_storage func, void *info=0); + */ + + /// iterate over all elements until condition, const info + void* first_that(Item_that_func_const func, const void *info=0) const; + + /// iterate over all elements until condition + void* first_that(Item_that_func func, void *info=0) const; + +private: + + /// constructor helper + void construct_new(int initial_rows); + private: + /// several record elements struct Chunk { - // the number of rows in chunk - int count; + int count; ///< the number of rows in chunk + /// item or a link to next chunk union union Row { Item *item; - Chunk *link; // link to the next chunk in chain + Chunk *link; ///< link to the next chunk in chain } rows[1]; // next rows are here } - *head; // the head chunk of the chunk chain + *head; ///< the head chunk of the chunk chain - // last allocated chunk - // helps appending Arrays + /** last allocated chunk + helps appending Arrays + */ Chunk *tail; - // next append would write to this record + /// next append would write to this record Chunk::Row *append_here; - // the address of place where lies address - // of the link to the next chunk to allocate + /** the address of place where lies address + of the link to the next chunk to allocate + */ Chunk::Row *link_row; private: @@ -119,9 +143,6 @@ private: // array size int fused_rows; - mutable int cache_chunk_base; - mutable Chunk *cache_chunk; - private: bool chunk_is_full() { @@ -135,4 +156,46 @@ private: //disabled Array& operator = (const Array&) { return *this; } }; + +/// handy array iterator +class Array_iter { +public: + + Array_iter(const Array& aarray) : array(aarray), + chunk(aarray.head), + row(chunk->rows), + countdown(chunk->count) { + } + + /// there are still elements + bool has_next() { + return !(chunk==array.tail && row==array.append_here); + } + + /// quickly extracts next Array::Item + Array::Item *next() { + // assuming: never called after has_next()! + if(countdown==0) { // end of chunk? + chunk=row->link; + row=chunk->rows; + countdown=chunk->count; + } + Array::Item *result=row->item; + row++; countdown--; + return result; + } + + /// quickly extracts next Array::Item as const String + const String *next_string() { + return const_cast(static_cast(next())); + } + +private: + const Array& array; + const Array::Chunk *chunk; + const Array::Chunk::Row *row; + int countdown; + +}; + #endif