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

Diff for /parser3/src/include/pa_table.h between versions 1.26 and 1.60

version 1.26, 2001/03/28 14:07:16 version 1.60, 2006/11/02 11:37:21
Line 1 Line 1
 /** @file  /** @file
         Parser: table class decl.          Parser: table class decl.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)  
   
         $Id$  
 */  */
   
 #ifndef PA_TABLE_H  #ifndef PA_TABLE_H
 #define PA_TABLE_H  #define PA_TABLE_H
   
   static const char * const IDENT_TABLE_H="$Date$";
   
 #include "pa_types.h"  #include "pa_types.h"
 #include "pa_array.h"  
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_string.h"  #include "pa_string.h"
 #include "pa_request.h"  
   
 /**   /** 
         VTable backend.          VTable backend.
Line 27 Line 24
   
         uses String for column names and data items          uses String for column names and data items
   
         hence most of tables are "named", no need to uptimize nameless onces          hence most of tables are "named", no need to uptimize nameless onces.
           rows and strings stored are read-only. once stored they can be removed,
           but not altered. that's handy for quick copying & co. see table:join
 */  */
 class Table : public Array {  class Table: public Array<ArrayString*> {
 public:  public:
           typedef ArrayString* columns_type;
   
         Table(Pool& apool,          Table(
                 const String *aorigin,                  columns_type acolumns,
                 Array *acolumns,                  size_t initial_rows=3);
                 int initial_rows=CR_INITIAL_ROWS_DEFAULT);          Table(const Table& src, Action_options& options);
   
         /// where this table came from, may be NULL  
         const String *origin_string() { return forigin_string; }  
   
         /// column names          /// gets column names
         const Array *columns() { return fcolumns; }          columns_type columns() { return fcolumns; }
   
         /// moves @a current pointer          /// moves @a current pointer
         void set_current(int acurrent) { fcurrent=acurrent; }          void set_current(size_t acurrent) {
                   assert(acurrent==0 || acurrent<count());
   
                   fcurrent=acurrent;
           }
         /// @return current pointer          /// @return current pointer
         int current() { return fcurrent; }          size_t current() const { return fcurrent; }
         void shift(int offset);          void offset(bool absolute, int offset);
   
           /** @return column index from @a column_name. '<0' if no such column
                   if no such - 'bark'
           */
           int column_name2index(const String& column, bool bark) const;
   
         /// @return item from @a column          /// @return item from @a column
         const String *item(int column) const;          const String* item(size_t column);
         /// @return item from @a column  
         const String *item(const String& column) const {           /// @return item from @a column. '0' if no such column
                 return item(column_name2index(column));           const String* item(const String& column) {
                   int index=column_name2index(column, false);
                   return index>=0?item(index):0;
         }          }
   
         /// saves to text file          /// saves to text file
         void save(bool nameless_save, const String& file_spec);          void save(bool nameless_save, const String& file_spec);
   
         bool locate(int column, const String& value);          template<typename I>
         bool locate(const String& column, const String& value) {          void table_for_each(void (*func)(Table& self, I* info), I* info, Action_options& o) {
                 return locate(column_name2index(column), value);                  if(!o.adjust(count()))
                           return;
   
                   size_t saved_current=current();
                   size_t row=o.offset;
                   if(o.reverse) { // reverse
                           for(size_t to=row-o.limit; row>=to; --row) {
                                   set_current(row);
                                   func(*this, info);
                           }
                   } else { // forward
                           for(size_t to=row+o.limit; row<to; row++) {
                                   set_current(row);
                                   func(*this, info);
                           }
                   }
                   set_current(saved_current);
         }          }
   
 private:          template<typename I>
                   bool table_first_that(bool (*func)(Table& self, I info), I info, Action_options& o) {
         // where this table came from, may be NULL                  if(!o.adjust(count()))
         const String *forigin_string;                          return false;
   
                   size_t saved_current=current();
                   size_t row=o.offset;
                   if(o.reverse) { // reverse
                           for(size_t i=0; i<o.limit; i++) {
                                   set_current(o.offset-i);
   
                                   if(func(*this, info))
                                           return true;
                           }
                   } else { // forward
                           for(size_t to=row+o.limit; row<to; row++) {
                                   set_current(row);
   
                                   if(func(*this, info))
                                           return true;
                           }
                   }
                   set_current(saved_current);
   
         // column name->number lookup table                  return false;
         Hash name2number;          }
   
         // current row  
         int fcurrent;  
   
         // columns          bool locate(int column, const String& value, Action_options& options);
         Array *fcolumns;          bool locate(const String& column, const String& value, Action_options& options);
   
         bool valid(int index) const { return index>=0 && index<size(); }  private:
           
           /// current row
           size_t fcurrent;
   
         const Array& at(int index) const {          /// columns
                 // force @c const result          columns_type fcolumns;
                 return *const_cast<const Array *>(static_cast<Array *>(get(index)));  
         }  
   
         /// @return column index from @a column_name          /// column name->number lookup table
         int column_name2index(const String& column) const;          typedef Hash<const String::Body, int> name2number_hash_class;
           name2number_hash_class* name2number;
   
           /// is that @c index falid?
           bool valid(size_t index) const { return index<count(); }
   
 };  };
   
Removed from v.1.26  
changed lines
  Added in v.1.60

E-mail: