--- parser3/src/include/pa_array.h 2001/01/27 15:21:05 1.2 +++ parser3/src/include/pa_array.h 2001/05/15 15:51:05 1.38 @@ -1,18 +1,11 @@ -/* - $Id: pa_array.h,v 1.2 2001/01/27 15:21:05 paf Exp $ -*/ +/** @file + Parser: array class decl. -/* + Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) - Array Chunk0 - ====== ======== - head--------------->[ptr] - append_here-------->[ptr] - link_row ........ - . . - . [ptr] - ...........>[link to the next chunk] + Author: Alexander Petrosyan (http://design.ru/paf) + $Id: pa_array.h,v 1.38 2001/05/15 15:51:05 parser Exp $ */ #ifndef PA_ARRAY_H @@ -20,88 +13,173 @@ #include +#include "pa_pool.h" #include "pa_types.h" +#include "pa_string.h" + +/** + Pooled Array. -class Pool; + Internal structure: + @verbatim + Array Chunk0 + ====== ======== + head--------------->[ptr] + append_here-------->[ptr] + link_row ........ + . . + . [ptr] + ...........>[link to the next chunk] + @endverbatim +*/ -class Array { +class Array : public Pooled { public: - typedef void *Item; + + /// 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); + + /// 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 { - CR_PREALLOCATED_COUNT=10, - CR_GROW_PERCENT=60 + CR_INITIAL_ROWS_DEFAULT=10, ///< default preallocated row count + CR_GROW_COUNT=10 ///< each time the Array chunk_is_full() array expanded() }; -private: - friend Pool; +public: + + Array(Pool& apool, int initial_rows=CR_INITIAL_ROWS_DEFAULT); + + /** + 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(value); } + + /// dirty hack to allow constant items storage. I long for Array + 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); + /// convinient way to get strings from Array. I long for Array + const String *get_string(int index) const { + return const_cast(static_cast(get(index))); + } + const String *quick_get_string(int index) const { + return const_cast(static_cast(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; - // the pool I'm allocated on - Pool *pool; + /// iterate over all elements until condition + void* first_that(First_that_func func, void *info=0) const; +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 + Item *item; + 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 - // next append would write to this record + /** last allocated chunk + helps appending Arrays + */ + Chunk *tail; + + /// 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: - // last chank allocated count - int curr_chunk_rows; // array size int fused_rows; - int cache_index; - Chunk::Row *cache_row; - int cache_countdown; - Chunk::Row *cache_link_row; + mutable int cache_chunk_base; + mutable Chunk *cache_chunk; private: - // new&constructors made private to enforce factory manufacturing at pool - void *operator new(size_t size, Pool *apool); - - void construct(Pool *apool, int initial_rows); - Array(Pool *apool) { - construct(apool, CR_PREALLOCATED_COUNT); - } - Array(Pool *apool, int initial_rows) { - construct(apool, initial_rows); - } - bool chunk_is_full() { return append_here == link_row; } - void expand(); - -public: - - int size() { return fused_rows; } - Array& operator += (Item src); - - /* - void put(int index, Item item); - Item get(int index); - */ - Item& operator [] (int index); + void expand(int chunk_rows); private: //disabled - Array& operator = (Array& src) { return *this; } - Array(Array& src) {} + //Array(Array&) { } + Array& operator = (const Array&) { return *this; } }; #endif