[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.25 and 1.48.2.10

version 1.25, 2001/03/28 09:01:21 version 1.48.2.10, 2003/02/04 15:59:05
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* 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<object_ptr<ArrayString> > {
 public:  public:
           typedef object_ptr<ArrayString> columns_type;
   
         Table(Pool& apool,          Table(
                 const String *aorigin,                  StringPtr aorigin_string,
                 Array *acolumns,                  columns_type acolumns,
                 int initial_rows=CR_INITIAL_ROWS_DEFAULT);                  int initial_rows=3);
           Table(const Table& src, int offset=0, int limit=0);
   
         /// where this table came from, may be NULL          /// where this table came from, may be NULL
         const String *origin_string() { return forigin_string; }          StringPtr 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(int acurrent) { fcurrent=acurrent; }
         /// @return current pointer          /// @return current pointer
         int current() { return fcurrent; }          int current() const { return fcurrent; }
         void shift(int offset);          void offset(bool absolute, int offset);
   
         /// @return item from @a column_name          /** @return column index from @a column_name. '<0' if no such column
         const String *item(const String& column) const {                   if no such - 'bark'
                 return item(column_name2index(column));           */
           int column_name2index(StringPtr column, bool bark) const;
   
           /// @return item from @a column
           StringPtr item(int column);
   
           /// @return item from @a column. '0' if no such column
           StringPtr item(StringPtr column) {
                   int index=column_name2index(column, false);
                   return index>=0?item(index):StringPtr(0);
         }          }
   
         /// saves to text file          /// saves to text file
         void save(bool nameless_save, const String& file_spec);          void save(bool nameless_save, object_ptr<const String> file_spec);
   
         bool locate(const String& column, const String& value);          bool locate(int column, StringPtr value);
           bool locate(StringPtr column, StringPtr value);
   
 private:  private:
                   
         // where this table came from, may be NULL          // where this table came from, may be NULL
         const String *forigin_string;          StringPtr forigin_string;
   
         // column name->number lookup table  
         Hash name2number;  
   
         // current row          // current row
         int fcurrent;          int fcurrent;
   
         // columns          // columns
         Array *fcolumns;          columns_type fcolumns;
   
         bool valid(int index) const { return index>=0 && index<size(); }          // column names are already referenced in fcolumns, no need to doublecheck references here
           // column name->number lookup table
         const Array& at(int index) const {          typedef Hash<const String&, int> name2number_hash_class;
                 // force @c const result          object_ptr<name2number_hash_class> name2number;
                 return *const_cast<const Array *>(static_cast<Array *>(get(index)));  
         }  
   
         /// @return column index from @a column_name          // we own columns?
         int column_name2index(const String& column) const;  
   
         const String *item(int column) const;          bool valid(int index) const { return index>=0 && index<count(); }
   
 };  };
   
   typedef object_ptr<Table> TablePtr;
   
 #endif  #endif
Removed from v.1.25  
changed lines
  Added in v.1.48.2.10

E-mail: