Vienna Database Library: vdbl_stview.h Source File

00001 // Standard view implementation -*- C++ -*-
00002 
00003 // $Id: vdbl_stview.h 699 2008-09-01 13:59:33Z mihaly $
00004 // Copyright (C) 2003 Hermann Schichl
00005 //
00006 // This file is part of the Vienna Database Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the Library GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // Library GNU General Public License for more details.
00016 
00017 // As a special exception, you may use this file as part of a free software
00018 // library without restriction.  Specifically, if other files instantiate
00019 // templates or use macros or inline functions from this file, or you compile
00020 // this file and link it with other files to produce an executable, this
00021 // file does not by itself cause the resulting executable to be covered by
00022 // the Library GNU General Public License.  This exception does not however
00023 // invalidate any other reasons why the executable file might be covered by
00024 // the Library GNU General Public License.
00025 
00031 #ifndef __VDBL_STVIEW_H
00032 #define __VDBL_STVIEW_H
00033 
00034 #include <iostream>
00035 #include <vdbl_table.h>
00036 #include <vdbl_view.h>
00037 
00038 __VDBL_BEGIN_NAMESPACE
00039 
00040 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00041 #pragma set woff 1209
00042 #endif
00043 
00045 
00049 class _VDBL_standardview : public _VDBL_view
00050 {
00051 private:
00052   typedef _VDBL_view _Base;
00053   
00055   typedef _VDBL_colid _V_colref;
00057   typedef _VDBL_rowid _V_rowref;
00059   typedef std::map<_VDBL_rowid, _VDBL_col> _V_colentry;
00061   typedef std::map<_V_colref, _V_colentry> _V_colcache;
00063   typedef std::vector<_V_rowref> _V_rows;
00065   typedef std::vector<_V_colref> _V_cols;
00066   
00067 private:
00069   std::pair<_VDBL_tableid,_VDBL_table *> _V_t;
00071   const _VDBL_context* _V_ctx;            
00072 
00074   unsigned int _V_lastchg;
00075 
00077   _V_colcache _V_cc;
00078 
00079 protected:
00084   _V_rows _V_r;
00088   _V_cols _V_c;
00089 
00090 private:
00092   std::map<std::string,_V_colref> _V_colnames;
00093 
00094   friend class _VDBL_table;
00095 
00096 public:
00098   typedef _Base::default_const_iterator defaults_const_iterator;
00099 
00100 protected:
00101   std::triple<_VDBL_tableid,_VDBL_colid,void*>
00102         _next_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
00103                       void *_d) const
00104     {
00105       _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
00106       if(_t == 0 && _c == 0) // end
00107         return std::make_triple(0,0,_d);
00108       ++_cit;
00109       while(_cit != _V_c.end())
00110       {
00111         if(_V_t.second->has_def(*_cit))
00112           break;
00113         ++_cit;
00114       }
00115       if(_cit == _V_c.end())
00116         return std::make_triple(0,0,_d);
00117       else
00118         return std::make_triple(_t,*_cit,_d);
00119     }
00120 
00121   std::triple<_VDBL_tableid,_VDBL_colid,void*>
00122         _prev_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
00123                       void *_d) const
00124     {
00125       _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
00126       if(_t == 0 && _c == 0) // end
00127         _cit = _V_c.end();
00128       --_cit;
00129       while(_cit != _V_c.begin())
00130       {
00131         if(_V_t.second->has_def(*_cit))
00132           break;
00133         --_cit;
00134       }
00135       if(_cit == _V_c.begin() && !_V_t.second->has_def(*_cit))
00136         return std::make_triple(0,0,_d);
00137       if(_cit == _V_c.end())
00138         return std::make_triple(0,0,_d);
00139       else
00140         return std::make_triple(_t,*_cit,_d);
00141     }
00142 
00143   void _destroy_def_data(void *&_d) const
00144     { delete (_V_cols::const_iterator*)_d; }
00145   
00146   void* _copy_def_data(void *_d) const
00147     { return (void *)
00148         new _V_cols::const_iterator(*(_V_cols::const_iterator*)_d); }
00149   
00150   std::triple<_VDBL_tableid,_VDBL_colid,void*>
00151         _next_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00152                   const _VDBL_colid& _c, void *_d) const
00153     {
00154       _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
00155       if(_t == 0 && _c == 0) // end
00156         return std::make_triple(0,0,_d);
00157       ++_cit;
00158       while(_cit != _V_c.end())
00159       {
00160         if(_V_t.second->has_def(*_cit) || _V_t.second->has_col(_r,*_cit))
00161           break;
00162         ++_cit;
00163       }
00164       if(_cit == _V_c.end())
00165         return std::make_triple(0,0,_d);
00166       else
00167         return std::make_triple(_t,*_cit,_d);
00168     }
00169 
00170   std::triple<_VDBL_tableid,_VDBL_colid,void*>
00171         _prev_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00172                   const _VDBL_colid& _c, void *_d) const
00173     {
00174       _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
00175       if(_t == 0 && _c == 0) // end
00176         _cit = _V_c.end();
00177       --_cit;
00178       while(_cit != _V_c.begin())
00179       {
00180         if(_V_t.second->has_def(*_cit) || _V_t.second->has_col(_r,*_cit))
00181           break;
00182         --_cit;
00183       }
00184       if(_cit == _V_c.begin() && !_V_t.second->has_def(*_cit) &&
00185          !_V_t.second->has_col(_r,*_cit))
00186         return std::make_triple(0,0,_d);
00187       if(_cit == _V_c.end())
00188         return std::make_triple(0,0,_d);
00189       else
00190         return std::make_triple(_t,*_cit,_d);
00191     }
00192 
00193   void _destroy_col_data(void *&_d) const
00194     { delete (_V_cols::const_iterator*)_d; }
00195   
00196   void* _copy_col_data(void *_d) const
00197     { return (void *)
00198         new _V_cols::const_iterator(*(_V_cols::const_iterator*)_d); }
00199   
00200   std::triple<_VDBL_tableid,_VDBL_rowid,void*>
00201         _next_row(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00202                   void * _d) const
00203     {
00204       std::pair<bool,void*>& _dr(*(std::pair<bool,void*>*)_d);
00205       if(_t == 0 && _r == 0) // end
00206         return std::make_triple(0,0,_d);
00207       
00208       bool at_end(false);
00209       _VDBL_rowid rret(0);
00210       if(_dr.first)
00211       {
00212         _V_rows::const_iterator& _rit(*(_V_rows::const_iterator*)_dr.second);
00213         ++_rit;
00214         if(_rit == _V_r.end())
00215           at_end = true;
00216         else
00217           rret = *_rit;
00218       }
00219       else
00220       {
00221         std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>& _rit(
00222            *(std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>*)_dr.second);
00223 
00224         ++(*_rit.first);
00225         if(*_rit.first == _rit.second->row_end())
00226           at_end = true;
00227         else
00228           rret = **_rit.first;
00229       }
00230       if(at_end)
00231         return std::make_triple(0,0,_d);
00232       else
00233         return std::make_triple(_t,rret,_d);
00234     }
00235 
00236   std::triple<_VDBL_tableid,_VDBL_rowid,void*>
00237         _prev_row(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00238                   void* _d) const
00239     {
00240       std::pair<bool,void*>& _dr(*(std::pair<bool,void*>*)_d);
00241       bool at_end(false);
00242       _VDBL_rowid rret(0);
00243       if(_dr.first)
00244       {
00245         _V_rows::const_iterator& _rit(*(_V_rows::const_iterator*)_dr.second);
00246 
00247         if(_t == 0 && _r == 0) // end
00248           _rit = _V_r.end();
00249         if(_rit == _V_r.begin())
00250           return std::make_triple(0,0,_d);
00251         --_rit;
00252         if(_rit == _V_r.end())
00253           at_end = true;
00254         else
00255           rret = *_rit;
00256       }
00257       else
00258       {
00259         std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>& _rit(
00260           *(std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>*)_dr.second);
00261 
00262         if(_t == 0 && _r == 0) // end
00263           *_rit.first = _rit.second->row_end();
00264         if(*_rit.first == _rit.second->row_begin())
00265           return std::make_triple(0,0,_d);
00266         --(*_rit.first);
00267         if(*_rit.first == _rit.second->row_end())
00268           at_end = true;
00269         else
00270           rret = **_rit.first;
00271       }
00272       if(at_end)
00273         return std::make_triple(0,0,_d);
00274       else
00275         return std::make_triple(_t,rret,_d);
00276     }
00277   
00278   void _destroy_row_data(void *&_d) const
00279     { std::pair<bool,void*>& _dr(*(std::pair<bool,void*>*)_d);
00280       if(_dr.first)
00281         delete (_V_rows::const_iterator*)_dr.second;
00282       else
00283       {
00284         std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>* _drs(
00285             (std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>*)_dr.second);
00286         delete (_VDBL_table::row_const_iterator*) _drs->first;
00287         delete (std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>*)
00288                 _dr.second;
00289       }
00290       delete (std::pair<bool,void*>*)_d;
00291       _d = NULL;
00292     }
00293   
00294   void* _copy_row_data(void *_d) const
00295     { std::pair<bool,void*>& _dr(*(std::pair<bool,void*>*)_d);
00296       void *_dd;
00297       if(_dr.first)
00298         _dd = new _V_rows::const_iterator(*(_V_rows::const_iterator*)_dr.second);
00299       else
00300       {
00301         std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>* _drs(
00302             (std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>*)_dr.second);
00303         _VDBL_table::row_const_iterator* _drti = 
00304           _drs->second->row_iterator_copy(*_drs->first);
00305         _dd = new std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>
00306                 (std::make_pair(_drti, _drs->second));
00307       }
00308       return (void *)
00309         new std::pair<bool,void*>(_dr.first,_dd);
00310     }
00311   
00312 private:
00314   bool _row_visible(const _VDBL_rowid& _r) const
00315   {
00316     if((view_type() == V_window || view_type() == V_hole) && _V_r.empty())
00317       return true;
00318     else
00319       return std::binary_search(_V_r.begin(), _V_r.end(), _r);
00320   }
00321 
00322 public:
00327   _VDBL_standardview(const _VDBL_tableid& __ti, _VDBL_table* __t,
00328                      const _VDBL_context& __c, _V_enum __e)
00329               : _Base(__e), _V_t(std::make_pair(__ti,__t)), _V_ctx(&__c),
00330                 _V_lastchg(__t->get_change_ctr()), _V_cc(), _V_r(), _V_c(),
00331                 _V_colnames()
00332       {
00333         _VDBL_table::col_const_iterator __x;
00334         for(__x = __t->col_begin(); __x != __t->col_end(); ++__x)
00335         {
00336           _V_colnames.insert(*__x);
00337           _V_c.push_back((*__x).second);
00338         }
00339         if(view_type() != V_window && view_type() != V_hole)
00340         {
00341           _VDBL_table::row_const_iterator __y;
00342           for(__y = __t->row_begin(); __y != __t->row_end(); ++__y)
00343             _V_r.push_back(*__y);
00344           std::sort(_V_r.begin(), _V_r.end());
00345         }
00346       }
00347 
00353   _VDBL_standardview(const _VDBL_tableid& __ti, _VDBL_table* __t,
00354                      const _VDBL_context& __c, _V_enum __e,
00355                      const std::vector<_VDBL_rowid>& _rs)
00356               : _Base(__e), _V_t(std::make_pair(__ti,__t)), _V_ctx(&__c),
00357                 _V_lastchg(__t->get_change_ctr()), _V_cc(), _V_r(_rs), _V_c(),
00358                 _V_colnames()
00359       {
00360         _VDBL_table::col_const_iterator __x;
00361         for(__x = __t->col_begin(); __x != __t->col_end(); ++__x)
00362         {
00363           _V_colnames.insert(*__x);
00364           _V_c.push_back((*__x).second);
00365         }
00366         std::sort(_V_r.begin(), _V_r.end());
00367       }
00368 
00372   _VDBL_standardview(const _VDBL_standardview& __v)
00373                 : _Base(__v), _V_t(__v._V_t), _V_ctx(__v._V_ctx),
00374                   _V_cc(__v._V_cc), _V_r(__v._V_r), _V_c(__v._V_c),
00375                   _V_colnames(__v._V_colnames)
00376       {}
00377                 
00378 
00382   virtual ~_VDBL_standardview() {}
00383 
00387   virtual _VDBL_view *new_copy() { return new _VDBL_standardview(*this); }
00391   virtual void destroy_copy(_VDBL_view* v) { delete (_VDBL_standardview*)v; }
00392 
00393 public:
00394   const std::type_info& get_colinfo(const std::string& _C_n,
00395                 std::triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
00396   {
00397     std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
00398     if(__x == _V_colnames.end())
00399     {
00400       _r = std::make_triple(false, _VDBL_colid(), _VDBL_colflags());
00401       return typeid(void);
00402     }
00403     return _V_t.second->get_colinfo(_C_n, _r);
00404   }
00405 
00406   const std::type_info& get_coltype(const std::string& _C_n) const
00407   {
00408     std::triple<bool,_VDBL_colid,_VDBL_colflags> _r;
00409     return get_colinfo(_C_n, _r);
00410   }
00411 
00412   bool insert(const std::vector<_T_colspec>& _row)
00413   {
00414     if(view_type() != V_hole)
00415       return false;
00418     _VDBL_rowid _ri;
00419     std::vector<std::pair<const std::string*,const _VDBL_col*> > _v;
00420     _v.reserve(_row.size());
00421     for(std::vector<_T_colspec>::const_iterator _x = _row.begin();
00422         _x != _row.end(); ++_x)
00423       _v.push_back(std::make_pair(&(*_x).first,&(*_x).second));
00424     bool ret = _V_t.second->insert(_v, _ri);
00425     if(!_V_r.empty())
00426       _V_r.insert(std::upper_bound(_V_r.begin(), _V_r.end(), _ri), _ri);
00427     return ret;
00428   }
00429 
00430   bool remove(std::pair<_VDBL_tableid,_VDBL_rowid> _r)
00431   {
00432     if(!_row_visible(_r.second))
00433       return false;
00434     if(view_type() != V_hole)
00435       return false;
00436     bool ret = _V_t.second->remove(_r.second);
00437     if(ret && !_V_r.empty())
00438       _V_r.erase(std::lower_bound(_V_r.begin(), _V_r.end(), _r.second));
00439     return ret;
00440   }
00441 
00442   bool has_col(const std::string& _C_n) const
00443   {
00444     std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
00445     return __x != _V_colnames.end();
00446   }
00447 
00448   std::pair<_VDBL_tableid,_VDBL_colid> get_col_id(const std::string& _C_n) const
00449   {
00450     std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
00451     if(__x == _V_colnames.end())
00452       return std::make_pair(_VDBL_tableid(),_VDBL_colid());
00453     return std::make_pair(_V_t.first,(*__x).second);
00454   }
00455 
00456   std::string get_col_name(const _VDBL_colid& _C_n) const
00457   {
00458     std::map<std::string,_V_colref>::const_iterator __x, __e(_V_colnames.end());
00459     for(__x = _V_colnames.begin(); __x != __e; ++__x)
00460       if((*__x).second == _C_n)
00461         return (*__x).first;
00462     return std::string();
00463   }
00464 
00465   const _VDBL_row& get_row(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00466                            bool& error) const
00467   {
00468     if(!_row_visible(_ri.second))
00469     {
00470       error = true;
00471       return ___empty_row_return;
00472     }
00473     return _V_t.second->get_row(_ri.second, error);
00474   }
00475  
00476   const _VDBL_col& get_raw_col(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00477                         const _VDBL_colid& _ci, _VDBL_row const *& _rr,
00478                         bool& error) const
00479   {
00480     if(!_row_visible(_ri.second))
00481     {
00482       error = true;
00483       return ___empty_col_return;
00484     }
00485     const _VDBL_row& _r(_V_t.second->get_row(_ri.second, error));
00486     if(error)
00487       return ___empty_col_return;
00488     _rr = &_r;
00489     const _VDBL_col& _c(_r.get_col(_ci, error));
00490     if(error)
00491       return _V_t.second->get_def(_ci, error);
00492     else
00493       return _c;
00494   }                                             
00495 
00497   bool add_visible(const std::vector<_VDBL_rowid>& _rs)
00498   {
00499     size_t _V_r_s(_V_r.size());
00500     if(_V_r_s > 0 || (view_type() != V_window && view_type() != V_hole))
00501     {
00502       _V_r.reserve(_V_r_s+_rs.size());
00503 
00504       _V_r.insert(_V_r.end(), _rs.begin(), _rs.end());
00505       _V_rows::iterator _V_r_it(_V_r.begin()+_V_r_s);
00506       std::sort(_V_r_it, _V_r.end());
00507       std::inplace_merge(_V_r.begin(), _V_r_it, _V_r.end());
00508     }
00509     return true;
00510   }
00511 
00514   bool rm_visible(const std::vector<_VDBL_rowid>& _rs)
00515   {
00516     if(!_V_r.empty() || (view_type() != V_window && view_type() != V_hole))
00517     {
00518       _V_rows::iterator _V_r_it_1, _V_r_it_2;
00519       std::vector<_VDBL_rowid>::const_iterator _rsc, _rse(_rs.end());
00520 
00521       for(_rsc = _rs.begin(); _rsc != _rse; ++_rsc)
00522       {
00523         _V_r_it_1 = std::lower_bound(_V_r.begin(), _V_r.end(), *_rsc);
00524         _V_r_it_2 = std::upper_bound(_V_r_it_1, _V_r.end(), *_rsc);
00525         if(_V_r_it_1 != _V_r_it_2)
00526           _V_r.erase(_V_r_it_1, _V_r_it_2);
00527       }
00528     }
00529     return true;
00530   }
00531 
00536   std::ostream& print_col(std::ostream& o,
00537                           const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00538                           const _VDBL_colid& _ci, bool& printed) const
00539   {
00540     bool error;
00541     const _VDBL_row* _rr;
00542         vdbl::col c(get_raw_col(_ri, _ci, _rr, error));
00543     if(error)
00544     {
00545       printed = false;
00546       return o;
00547     }
00548     printed = true;
00549     c.setcontext(_V_ctx, _rr);
00550     return o << c;
00551   }
00552  
00558   template <class _TR>
00559   bool get(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00560                                  const _VDBL_colid& _ci, _TR& r) const
00561   {
00562     bool error;
00563     const _VDBL_row* _rr;
00564     vdbl::col c(get_raw_col(_ri, _ci, _rr, error));
00565     if(error)
00566       return false;
00567     c.setcontext(_V_ctx, _rr);
00568     c.get(r);
00569     return true;
00570   }
00571  
00580   template <class _TR>
00581   bool get_raw_ptr(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00582                    const _VDBL_colid& _ci, _TR const *& r) const
00583   {
00584     bool error;
00585     const _VDBL_row* _rr;
00586     vdbl::col c(get_raw_col(_ri, _ci, _rr, error));
00587     if(error)
00588       return false;
00589     c.setcontext(_V_ctx, _rr);
00590     c.get_ptr(r);
00591     return true;
00592   }
00593  
00594   const _VDBL_col& get_def(const std::pair<_VDBL_tableid,_VDBL_colid>& _ri,
00595                            bool& error) const
00596   { return _V_t.second->get_def(_ri.second, error); }
00597 
00598   default_const_iterator defaults_begin() const
00599   {
00600     _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
00601     while(*_rit != _V_c.end())
00602     {
00603       if(_V_t.second->has_def(**_rit))
00604         break;
00605       ++*_rit;
00606     }
00607     if(*_rit == _V_c.end())
00608       return default_const_iterator(this,0,0,(void*)_rit);
00609     return default_const_iterator(this,_V_t.first,**_rit,(void*)_rit);
00610   }
00611 
00612   default_const_iterator defaults_end() const
00613   {
00614     _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
00615     return default_const_iterator(this,0,0,(void*)_rit);
00616   }
00617 
00618   col_const_iterator cols_begin(const _VDBL_rowid& _r) const
00619   {
00620     _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
00621     while(*_rit != _V_c.end())
00622     {
00623       if(_V_t.second->has_col(_r,**_rit) || _V_t.second->has_def(**_rit))
00624         break;
00625       ++*_rit;
00626     }
00627     if(*_rit == _V_c.end())
00628       return col_const_iterator(this,0,_r,0,(void*)_rit);
00629     return col_const_iterator(this,_V_t.first,_r,**_rit,(void*)_rit);
00630   }
00631 
00632   col_const_iterator cols_end(const _VDBL_rowid& _r) const
00633   {
00634     _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
00635     return col_const_iterator(this,0,_r,0,(void*)_rit);
00636   }
00637 
00638   row_const_iterator rows_begin() const
00639   {
00640     std::pair<bool,void*>* _dr = new std::pair<bool,void*>(true,NULL);
00641     _VDBL_tableid ti;
00642     _VDBL_rowid ri;
00643 
00644     if((view_type() == V_window || view_type() == V_hole) && _V_r.empty())
00645     {
00646       std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>* _dd =
00647         new std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>
00648           (_V_t.second->row_iterator_copy(_V_t.second->row_begin()), _V_t.second);
00649       if(*_dd->first == _V_t.second->row_end())
00650       {
00651         ti = 0; ri = 0;
00652       }
00653       else
00654       {
00655         ti = _V_t.first;
00656         ri = **_dd->first;
00657       }
00658       _dr->first = false;
00659       _dr->second = (void*)_dd;
00660     }
00661     else
00662     {
00663       _V_rows::const_iterator* _rit = new _V_rows::const_iterator(_V_r.begin());
00664       if(*_rit == _V_r.end())
00665       {
00666         ti = 0; ri = 0;
00667       }
00668       else
00669       {
00670         ti = _V_t.first;
00671         ri = **_rit;
00672       }
00673       _dr->second = (void*)_rit;
00674     }
00675     return row_const_iterator(this,ti,ri,(void*)_dr);
00676   }
00677 
00678   row_const_iterator rows_end() const
00679   {
00680     std::pair<bool,void*>* _dr = new std::pair<bool,void*>(true,NULL);
00681     if((view_type() == V_window || view_type() == V_hole) && _V_r.empty())
00682     {
00683       std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>* _dd =
00684         new std::pair<_VDBL_table::row_const_iterator*,_VDBL_table*>
00685           (_V_t.second->row_iterator_copy(_V_t.second->row_end()), _V_t.second);
00686       _dr->first = false;
00687       _dr->second = (void*)_dd;
00688     }
00689     else
00690     {
00691       _V_rows::const_iterator* _rit = new _V_rows::const_iterator(_V_r.end());
00692       _dr->second = (void*)_rit;
00693     }
00694     return row_const_iterator(this,0,0,(void*)_dr);
00695   }
00696 };
00697 
00699 
00704 class view : public _VDBL_standardview
00705 {
00706   typedef _VDBL_standardview _Base;
00707 
00708 public:
00709   typedef _V_enum view_enum;
00710 
00711 public:
00716   view(const _VDBL_tableid& __ti, _VDBL_table* __t,
00717        const _VDBL_context& __c, _V_enum __e = V_hole)
00718                 : _VDBL_standardview(__ti,__t,__c,__e) {}
00719 
00723   view(const view& _v) : _VDBL_standardview(_v) {}
00724 
00728   virtual view *new_copy() { return new view(*this); }
00732   virtual void destroy_copy(view* v) { delete (view*)v; }
00733 
00738   template <class _TR>
00739   bool get(const tableid& _ti, const rowid& _ri, const colid& _ci, _TR& r) const
00740   { return _Base::get(std::make_pair(_ti, _ri), _ci, r); }
00741 
00748   template <class _TR>
00749   bool get_raw_ptr(const tableid& _ti, const rowid& _ri, const colid& _ci,
00750                    _TR const *& r) const
00751   { return _Base::get_raw_ptr(std::make_pair(_ti, _ri), _ci, r); }
00752 
00754 
00758   template <class _TR>
00759   bool get(const rowid& _ri, const std::string& _c, _TR& r) const
00760   { std::pair<tableid,colid> _tci(get_col_id(_c));
00761     return _Base::get(std::make_pair(_tci.first, _ri), _tci.second, r); }
00762 
00763   template <class _TR>
00764   bool get(const rowid& _ri, const char* _c, _TR& r) const
00765   { return get(_ri, std::string(_c), r); }
00767 
00773   const col& get_raw_col(const std::pair<tableid,rowid>& _ri, const colid& _ci,
00774                      row const *& _rr, bool& error) const
00775   { return _Base::get_raw_col(_ri, _ci, (_VDBL_row const *&)_rr, error); }
00776 };
00777 
00778 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00779 #pragma reset woff 1209
00780 #endif
00781 
00782 __VDBL_END_NAMESPACE
00783 
00784 #endif /* __VDBL_STVIEW_H */
00785 
00786 // Local Variables:
00787 // mode:C++
00788 // End: