[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.15 and 1.56

version 1.15, 2001/03/19 17:42:13 version 1.56, 2003/11/20 16:34:25
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-2003 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"  
   
 /// parser \b table class backend  /** 
 /**          VTable backend.
         holds   
           holds:
         - column names[if any]          - column names[if any]
         - data rows          - data rows
         - current row pointer          - current row pointer
   
         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& asource,                  columns_type acolumns,
                 Array *acolumns,                  size_t initial_rows=3);
                 int initial_rows=CR_INITIAL_ROWS_DEFAULT);          Table(const Table& src, Action_options& options);
   
         /// the string source of table's data  
         //const String& source() { return fsource; }  
   
         /// column names  
         const Array *columns() { return fcolumns; }  
   
         /// moves \a current pointer  
         void set_current(int acurrent) { fcurrent=acurrent; }  
         /// \return current pointer  
         int get_current() { return fcurrent; }  
   
         /// \return item from \a column_name          /// gets column names
         const String *item(const String& column_name);          columns_type columns() { return fcolumns; }
   
 private:          /// moves @a current pointer
           void set_current(size_t acurrent) {
                   assert(acurrent==0 || acurrent<count());
   
                   fcurrent=acurrent;
           }
           /// @return current pointer
           size_t current() const { return fcurrent; }
           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
           const String* item(size_t column);
   
           /// @return item from @a column. '0' if no such column
           const String* item(const String& column) {
                   int index=column_name2index(column, false);
                   return index>=0?item(index):0;
           }
   
         // the base origin of table's data          /// saves to text file
         const String& fsource;          void save(bool nameless_save, const String& file_spec);
   
         // column name->number lookup table          template<typename I>
         Hash name2number;          void table_for_each(void (*func)(Table& self, I* info), I* info, Action_options& o) {
                   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);
           }
   
         // current row          template<typename I>
         int fcurrent;          bool table_first_that(bool (*func)(Table& self, I info), I info, Action_options& o) {
                   if(!o.adjust(count()))
                           return false;
   
                   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);
   
                                   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);
   
         // columns                  return false;
         Array *fcolumns;          }
   
         bool valid(int index) { return index>=0 && index<size();        }  
   
         const Array& at(int index);          bool locate(int column, const String& value, Action_options& options);
           bool locate(const String& column, const String& value, Action_options& options);
   
   private:
           
           /// current row
           size_t fcurrent;
   
           /// columns
           columns_type fcolumns;
   
           /// column name->number lookup table
           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(); }
   
         const String *item(int column_index) {  
                 return valid(fcurrent)?at(fcurrent).get_string(column_index):0;  
         }  
 };  };
   
 #endif  #endif
Removed from v.1.15  
changed lines
  Added in v.1.56

E-mail: