[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.65 and 1.78

version 1.65, 2005/08/09 08:14:49 version 1.78, 2009/04/30 04:40:30
Line 1 Line 1
 /** @file  /** @file
         Parser: Array & Array_iterator classes decls.          Parser: Array & Array_iterator classes decls.
   
         Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
Line 56  public: Line 56  public:
                 bool adjust(size_t count) {                  bool adjust(size_t count) {
                         if(!count || !limit)                          if(!count || !limit)
                                 return false;                                  return false;
                         size_t row=offset;                          if(offset>=count)
                         if(row>=count)  
                                 return false;                                  return false;
                         // max(limit)                          // max(limit)
                         size_t m=reverse?                          size_t m=reverse?
                                 offset                                  offset+1
                                 :count-offset;                                  :count-offset;
                         if(!m)                          if(!m)
                                 return false;                                  return false;
Line 77  public: Line 76  public:
   
         typedef T element_type;          typedef T element_type;
   
         Array(size_t initial=3):          inline Array(size_t initial=0):
                 fallocated(initial>3?initial:3),                  fallocated(initial),
                 fused(0)                  fused(0)
         {          {
                 felements=static_cast<T*>(malloc(fallocated*sizeof(T)));                  felements=fallocated?(T *)pa_malloc(fallocated*sizeof(T)):0;
         }          }
   
   #ifdef USE_DESTRUCTORS 
           inline ~Array(){
                   if(felements)
                           pa_free(felements);
           }
   #endif
   
         /// how many items are in Array          /// how many items are in Array
         size_t count() const { return fused; }          inline size_t count() const { return fused; }
         /// append to array          /// append to array
         Array& operator += (T src) {          inline Array& operator+=(T src) {
                 if(is_full())                  if(is_full())
                         expand(2);                          expand(fallocated>0?2:3); // 3 is PAF default, confirmed by tests
   
                 felements[fused++]=src;                  felements[fused++]=src;
   
Line 138  public: Line 144  public:
         }          }
   
         /// get index-element          /// get index-element
         T get(size_t index) const {          inline T get(size_t index) const {
                 assert(index<count());                  assert(index<count());
                 return felements[index];                  return felements[index];
         }          }
   
         /// ref version of get          /// ref version of get
         T& get_ref(size_t index) const {          inline T& get_ref(size_t index) const {
                 assert(index<count());                  assert(index<count());
                 return felements[index];                  return felements[index];
         }          }
   
         /// put index-element          /// put index-element
         void put(size_t index, T element) {          inline void put(size_t index, T element) {
                 assert(index<count());                  assert(index<count());
                 felements[index]=element;                  felements[index]=element;
         }          }
   
         T operator [](size_t index) const { return get(index); }          inline T operator [](size_t index) const { return get(index); }
   
         /// iterate over all elements          /// iterate over all elements
         template<typename I> void for_each(void (*callback)(T, I), I info) const {          template<typename I> void for_each(void (*callback)(T, I), I info) const {
Line 165  public: Line 171  public:
         }          }
   
         /// iterate over all elements          /// iterate over all elements
           template<typename I> void for_each(bool (*callback)(T, I), I info) const {
                   T *last=felements+fused;
                   for(T *current=felements; current<last; current++)
                           if(callback(*current, info))
                                   return;
           }
   
           /// iterate over all elements
         template<typename I> void for_each_ref(void (*callback)(T&, I), I info) {          template<typename I> void for_each_ref(void (*callback)(T&, I), I info) {
                 T *last=felements+fused;                  T *last=felements+fused;
                 for(T *current=felements; current<last; current++)                  for(T *current=felements; current<last; current++)
Line 181  public: Line 195  public:
                 return T(0);                  return T(0);
         }          }
   
           inline T* ptr(size_t index){
                   return felements + index;
           }
   
 protected:  protected:
   
         bool is_full() {          bool is_full() {
                 return fused == fallocated;                  return fused == fallocated;
         }          }
         void expand(size_t delta) {          void expand(size_t delta) {
                 size_t new_allocated=fallocated+delta;                  if(fallocated){
                 felements = (T *)realloc(felements, new_allocated*sizeof(T));                          size_t new_allocated=fallocated+delta;
                 memset(&felements[fallocated], 0, delta*sizeof(T));                          felements=(T *)pa_realloc(felements, new_allocated*sizeof(T));
                 fallocated=new_allocated;                          fallocated=new_allocated;
                   } else {
                           fallocated=delta;
                           felements=(T *)pa_malloc(fallocated*sizeof(T));
                   }
         }          }
   
 private: //disabled  private: //disabled
Line 228  public: Line 250  public:
         }          }
   
         /// quickly extracts next Array element          /// quickly extracts next Array element
         const T next() {          T next() {
                 return *(fcurrent++);                  return *(fcurrent++);
         }          }
   
Removed from v.1.65  
changed lines
  Added in v.1.78

E-mail: