Annotation of parser3/src/include/pa_array.h, revision 1.57.2.27.2.4

1.24      paf         1: /** @file
1.57.2.2  paf         2:        Parser: Array & Array_iterator classes decls.
1.26      paf         3: 
1.57.2.16  paf         4:        Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
1.53      paf         5:        Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.1       paf         6: */
                      7: 
1.24      paf         8: #ifndef PA_ARRAY_H
                      9: #define PA_ARRAY_H
1.54      paf        10: 
1.57.2.27.2.4! (paf       11:: static const char* IDENT_ARRAY_H="$Date: 2003/03/19 16:28:07 $";
1.24      paf        12: 
1.57.2.25  paf        13: // includes
                     14: 
                     15: #include "pa_memory.h"
1.57.2.3  paf        16: #include "pa_exception.h"
1.24      paf        17: 
1.57.2.25  paf        18: // forwards
1.42      parser     19: 
1.57.2.25  paf        20: template<typename T> class Array_iterator;
1.24      paf        21: 
1.57.2.25  paf        22: /// Simple Array
1.57.2.2  paf        23: template<typename T> class Array: public PA_Object {
1.1       paf        24: 
1.57.2.9  paf        25:        friend class Array_iterator<T>;
1.57.2.2  paf        26: 
1.57.2.13  paf        27: protected:
                     28: 
                     29:        /// elements[growing size] here
                     30:        T *felements;
                     31: 
1.57.2.2  paf        32:        // allocated size
                     33:        int fallocated;
1.1       paf        34: 
1.57.2.13  paf        35:        // array size
                     36:        int fused;
                     37: 
1.57.2.2  paf        38: public:
                     39:        typedef T element_type;
1.7       paf        40: 
1.57.2.27.2.2  (paf       41::       Array(int initial=3):
1.57.2.27  paf        42:                fallocated(initial>3?initial:3),
1.57.2.2  paf        43:                fused(0)
                     44:        {
1.57.2.27.2.2  (paf       45::               felements=static_cast<T*>(malloc(fallocated*sizeof(T)));
1.57.2.2  paf        46:        }
1.24      paf        47: 
1.57.2.2  paf        48:        /// how many items are in Array
                     49:        int count() const { return fused; }
                     50:        /// append to array
                     51:        Array& operator += (T src) {
                     52:                if(is_full())
1.57.2.27.2.4! (paf       53::                       expand(2);
1.24      paf        54: 
1.57.2.2  paf        55:                felements[fused++]=src;
1.37      paf        56: 
1.57.2.2  paf        57:                return *this;
1.34      paf        58:        }
1.35      paf        59: 
1.57.2.2  paf        60:        /// append other Array portion to this one. starting from offset
                     61:        Array& append(const Array& src, int offset=0, int limit=0) {
1.57.2.25  paf        62:                if(offset<0) {
1.57.2.4  paf        63:                        throw Exception(0, 
1.57.2.27.2.3  (paf       64::                               0,
1.57.2.25  paf        65:                                "Array::append(offset=%d) out <0", offset);
                     66:                        //return Nothing; // never
1.57.2.2  paf        67:                }
                     68:                // fix limit
                     69:                {
                     70:                        int m=src.count()-offset;
                     71:                        if(!m || limit<0)
                     72:                                return *this;
                     73:                        if(!limit || limit>m)
                     74:                                limit=m;
                     75:                }
1.29      paf        76: 
1.57.2.23  paf        77:                int delta=limit-(fallocated-fused);
                     78:                if(delta>0)
                     79:                        expand(delta);
                     80: 
                     81:                T* from=&src.felements[offset];
                     82:                T* to=&felements[fused];
                     83:                T* from_end=from+limit;
                     84:                while(from<from_end)
                     85:                        *to++=*from++;
                     86:                
                     87:                fused+=limit;
1.57.2.4  paf        88:                return *this;
1.57.2.2  paf        89:        }
1.49      paf        90: 
1.57.2.2  paf        91:        /// get index-element
1.57.2.21  paf        92:        T& get(int index) const {
1.57.2.4  paf        93:                if(!(index>=0 && index<count())) {
                     94:                        throw Exception(0, 
1.57.2.27.2.3  (paf       95::                               0,
1.57.2.2  paf        96:                                "Array::get(%d) out of range [0..%d]", index, count()-1);
1.57.2.15  paf        97:                        return felements[0]; // never
1.57.2.2  paf        98:                }
1.29      paf        99: 
1.57.2.2  paf       100:                return felements[index];
                    101:        }
1.57.2.12  paf       102: 
1.57.2.21  paf       103:        T& operator [](int index) const { return get(index); }
1.32      paf       104: 
1.57.2.2  paf       105:        /// put index-element
1.57.2.15  paf       106:        void put(int index, T& element) {
1.57.2.11  paf       107:                if(!(index>=0 && index<count())) {
1.57.2.4  paf       108:                        throw Exception(0, 
1.57.2.27.2.3  (paf      109::                               0, 
1.57.2.11  paf       110:                                "Array::put(%d) out of range [0..%d]", index, count()-1);
1.57.2.2  paf       111:                        return; // never
                    112:                }
                    113:                felements[index]=element;
                    114:        }
1.1       paf       115: 
1.7       paf       116: 
1.57.2.2  paf       117:        /// iterate over all elements
1.57.2.6  paf       118:        template<typename I> void for_each(void (*callback)(T, I), I info) const {
1.57.2.2  paf       119:                T *last=felements+fused;
                    120:                for(T *current=felements; current<last; current++)
                    121:                        callback(*current, info);
                    122:        }
1.1       paf       123: 
1.57.2.2  paf       124:        /// iterate over all elements until condition becomes true, return that element
1.57.2.6  paf       125:        template<typename I> T first_that(bool (*callback)(T, I), I info) const {
1.57.2.2  paf       126:                T *last=felements+fused;
                    127:                for(T *current=felements; current<last; current++)
                    128:                        if(callback(*current, info))
                    129:                                return *current;
1.7       paf       130: 
1.57.2.20  paf       131:                return T(0);
1.57.2.2  paf       132:        }
1.1       paf       133: 
1.57.2.3  paf       134: protected:
1.1       paf       135: 
1.57.2.2  paf       136:        bool is_full() {
                    137:                return fused == fallocated;
                    138:        }
                    139:        void expand(int delta) {
1.57.2.22  paf       140:                felements = (T *)realloc(felements, (fallocated+delta)*sizeof(T));
                    141:                memset(&felements[fallocated], 0, delta*sizeof(T));
1.57.2.2  paf       142:                fallocated+=delta;
1.1       paf       143:        }
1.2       paf       144: 
1.1       paf       145: private: //disabled
                    146: 
1.12      paf       147:        Array& operator = (const Array&) { return *this; }
1.57.2.5  paf       148: };
                    149: 
1.42      parser    150: 
1.57.2.27.2.1  (paf      151:: /** Array iterator, usage:
                    152::       @code
                    153::       // Array<T> a;
                    154::       Array_iterator<T> i(a);
                    155::       while(i.has_next()) {
                    156::               T& element=i.next();
                    157::               ...
                    158::       }       
                    159::       @endcode
                    160:: */
1.57.2.2  paf       161: template<typename T> class Array_iterator {
                    162: 
1.57.2.27.2.1  (paf      163::       const Array<T>& farray;
                    164::       T *fcurrent;
                    165::       T *flast;
                    166:: 
                    167:: public:
                    168:: 
                    169::       Array_iterator(const Array<T>& aarray): farray(aarray) {
                    170::               fcurrent=farray.felements;
                    171::               flast=farray.felements+farray.count();
                    172::       }
                    173:: 
                    174::       /// there are still elements
                    175::       bool has_next() {
                    176::               return fcurrent<flast;
                    177::       }
                    178:: 
                    179::       /// quickly extracts next Array element
                    180::       const T& next() {
                    181::               return *(fcurrent++);
                    182::       }
                    183:: 
                    184:: };
                    185:: 
                    186:: /** Nonconst array iterator, usage:
                    187::       @code
                    188::       // Array<T> a;
                    189::       Array_iterator<T> i(a);
                    190::       while(i.has_next()) {
                    191::               T& element=i.next();
                    192::               ...
                    193::       }       
                    194::       @endcode
                    195:: */
                    196:: template<typename T> class Array_modifing_iterator {
                    197:: 
1.57.2.9  paf       198:        Array<T>& farray;
1.57.2.2  paf       199:        T *fcurrent;
                    200:        T *flast;
                    201: 
1.42      parser    202: public:
                    203: 
1.57.2.27.2.1  (paf      204::       Array_modifing_iterator(Array<T>& aarray): farray(aarray) {
1.57.2.9  paf       205:                fcurrent=farray.felements;
                    206:                flast=farray.felements+farray.count();
1.42      parser    207:        }
                    208: 
                    209:        /// there are still elements
                    210:        bool has_next() {
1.57.2.2  paf       211:                return fcurrent<flast;
1.42      parser    212:        }
                    213: 
1.57.2.2  paf       214:        /// quickly extracts next Array element
1.57.2.17  paf       215:        T& next() {
1.57.2.9  paf       216:                return *(fcurrent++);
1.42      parser    217:        }
                    218: 
1.1       paf       219: };
                    220: 
                    221: #endif

E-mail: