vdbl_view.h Source File

00001 // Copyright (C) 2003 Hermann Schichl
00002 //
00003 // This file is part of the Vienna Database Library.  This library is free
00004 // software; you can redistribute it and/or modify it under the
00005 // terms of the Library GNU General Public License as published by the
00006 // Free Software Foundation; either version 2, or (at your option)
00007 // any later version.
00008 
00009 // This library is distributed in the hope that it will be useful,
00010 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00011 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012 // Library GNU General Public License for more details.
00013 
00014 // As a special exception, you may use this file as part of a free software
00015 // library without restriction.  Specifically, if other files instantiate
00016 // templates or use macros or inline functions from this file, or you compile
00017 // this file and link it with other files to produce an executable, this
00018 // file does not by itself cause the resulting executable to be covered by
00019 // the Library GNU General Public License.  This exception does not however
00020 // invalidate any other reasons why the executable file might be covered by
00021 // the Library GNU General Public License.
00022 
00028 #ifndef __VDBL_VIEW_H
00029 #define __VDBL_VIEW_H
00030 
00031 #include <algorithm>
00032 #include <map>
00033 #include <vector>
00034 #include <typeinfo>
00035 #include <vdbl_table.h>
00036 #include <vdbl_triple.h>
00037 #include <vdbl_config.h>
00038 #include <vdbl_types.h>
00039 
00040 __VDBL_BEGIN_NAMESPACE
00041 
00042 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00043 #pragma set woff 1209
00044 #endif
00045 
00046 class _VDBL_table;
00047 
00049 
00065 typedef enum { V_window,
00066                V_transparent,
00067                V_frozen,
00068                V_materialized,
00069                V_independent
00070              } _V_enum;
00071 
00073 
00078 class _VDBL_view
00079 {
00080 public:
00084   typedef std::pair<std::string,_VDBL_col> _T_colspec;
00085 
00086 private:
00088   _V_enum _V_e;
00090   unsigned int change_ctr;
00091 
00092 protected:
00093   
00095   void made_change() { change_ctr++; }
00097   unsigned int get_change_ctr() const { return change_ctr; }
00098 
00104   virtual triple<_VDBL_tableid,_VDBL_colid,void*>
00105         _next_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
00106                       void* _d) const
00107                 VDBL_PURE_VIRTUAL
00108 
00114   virtual triple<_VDBL_tableid,_VDBL_colid,void*>
00115         _prev_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
00116                       void* _d) const
00117                 VDBL_PURE_VIRTUAL
00118 
00123   virtual void _destroy_def_data(void*& _d) const {}
00124 
00129   virtual void* _copy_def_data(void* _d) const VDBL_PURE_VIRTUAL
00130 
00136   virtual triple<_VDBL_tableid,_VDBL_colid,void*>
00137         _next_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00138                   const _VDBL_colid& _c, void* _d) const
00139                 VDBL_PURE_VIRTUAL
00140 
00146   virtual triple<_VDBL_tableid,_VDBL_colid,void*>
00147         _prev_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00148                   const _VDBL_colid& _c, void* _d) const
00149                 VDBL_PURE_VIRTUAL
00150 
00155   virtual void _destroy_col_data(void*& _d) const {}
00156 
00161   virtual void* _copy_col_data(void* _d) const VDBL_PURE_VIRTUAL
00162 
00168   virtual triple<_VDBL_tableid,_VDBL_rowid,void*>
00169         _next_row(const _VDBL_tableid& _t, const _VDBL_rowid& _c,
00170                       void* _d) const
00171                 VDBL_PURE_VIRTUAL
00172 
00178   virtual triple<_VDBL_tableid,_VDBL_rowid,void*>
00179         _prev_row(const _VDBL_tableid& _t, const _VDBL_rowid& _c,
00180                       void* _d) const
00181                 VDBL_PURE_VIRTUAL
00182 
00187   virtual void _destroy_row_data(void*& _d) const {}
00188 
00193   virtual void* _copy_row_data(void* _d) const VDBL_PURE_VIRTUAL
00194 
00195 public:
00201   class _default_iterator_base
00202   {
00203   public:
00204     typedef size_t size_type;
00205     typedef ptrdiff_t difference_type;
00206     typedef std::bidirectional_iterator_tag iterator_category;
00207 
00208     _VDBL_tableid _DI_ti;
00209     _VDBL_colid _DI_ci;
00210     const _VDBL_view* _DI_v;
00211     void* _DI_data;
00212 
00213     _default_iterator_base(const _VDBL_view* __x, const _VDBL_tableid& __t,
00214                            const _VDBL_colid& __c, void *__data = NULL)
00215                 : _DI_ti(__t), _DI_ci(__c), _DI_v(__x), _DI_data(__data) { }
00216 
00217     _default_iterator_base() : _DI_ti(),_DI_ci(),_DI_v(NULL),_DI_data(NULL) {}
00218 
00219     _default_iterator_base(const _default_iterator_base& _dib)
00220         : _DI_ti(_dib._DI_ti),_DI_ci(_dib._DI_ci),_DI_v(_dib._DI_v)
00221         {
00222           if(_DI_v && _DI_data)
00223             _DI_data = _DI_v->_copy_def_data(_dib._DI_data);
00224           else
00225             _DI_data = NULL;
00226         }
00227 
00228     virtual ~_default_iterator_base()
00229         { if(_DI_v && _DI_data) _DI_v->_destroy_def_data(_DI_data); }
00230 
00231     void _D_incr()
00232         { triple<_VDBL_tableid,_VDBL_colid,void*>
00233                            _x(_DI_v->_next_def_col(_DI_ti, _DI_ci, _DI_data));
00234           _DI_ti = _x.first;
00235           _DI_ci = _x.second;
00236           _DI_data = _x.third;
00237         }
00238 
00239     void _D_decr()
00240         { triple<_VDBL_tableid,_VDBL_colid,void*>
00241                            _x(_DI_v->_prev_def_col(_DI_ti, _DI_ci, _DI_data));
00242           _DI_ti = _x.first;
00243           _DI_ci = _x.second;
00244           _DI_data = _x.third;
00245         }
00246 
00247     
00248     bool operator==(const _default_iterator_base& __x) const
00249               { return _DI_v == __x._DI_v && _DI_ti == __x._DI_ti &&
00250                        _DI_ci == __x._DI_ci; }
00251 
00252     bool operator!=(const _default_iterator_base& __x) const
00253               { return _DI_v != __x._DI_v || _DI_ti != __x._DI_ti ||
00254                        _DI_ci != __x._DI_ci; }
00255 
00256     _default_iterator_base& operator=(const _default_iterator_base& __x)
00257               {
00258                 _DI_v = __x._DI_v; _DI_ti = __x._DI_ti; _DI_ci = __x._DI_ci;
00259                 if(_DI_v && _DI_data) _DI_v->_destroy_def_data(_DI_data);
00260                 if(_DI_v && __x._DI_data)
00261                   _DI_data = _DI_v->_copy_def_data(__x._DI_data);
00262                 else
00263                   _DI_data = NULL;
00264                 return *this;
00265               }
00266   };
00267 
00273   template<typename _Tp, typename _Ref, typename _Ptr>
00274   struct _default_iterator : public _default_iterator_base
00275   {
00276   public:
00277     typedef _default_iterator<_Tp,_Tp&,_Tp*>             iterator;
00278     typedef _default_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00279     typedef _default_iterator<_Tp,_Ref,_Ptr>             _Self;
00280 
00281     typedef _Tp value_type;
00282     typedef _Ptr pointer;
00283     typedef _Ref reference;
00284 
00285     _default_iterator(const _VDBL_view* __x, const _VDBL_tableid& __t,
00286                       const _VDBL_colid& __c, void *__d = NULL)
00287                                 : _default_iterator_base(__x,__t,__c,__d) { }
00288 
00289     _default_iterator() : _default_iterator_base() { }
00290 
00291     _default_iterator(const iterator& __x)
00292         : _default_iterator_base(__x._DI_v, __x._DI_ti, __x._DI_ci,
00293                                  __x._DI_data) { }
00294 
00295     reference operator*() const
00296         {
00297           bool dummy;
00298           return _DI_v->get_def(std::make_pair(_DI_ti, _DI_ci), dummy);
00299         }
00300 
00301     _VDBL_colid id() const { return _DI_ci; }
00302     _VDBL_tableid tid() const { return _DI_ti; }
00303 
00304     pointer operator->() const { return &(operator*()); }
00305 
00306     _Self& operator++() { this->_D_incr(); return *this; }
00307 
00308     _Self operator++(int)
00309         { _Self __tmp = *this; this->_D_incr(); return __tmp; }
00310 
00311     _Self& operator--() { this->_D_decr(); return *this; }
00312 
00313     _Self operator--(int)
00314         { _Self __tmp = *this; this->_D_decr(); return __tmp; }
00315 
00316     _Self& operator=(const _Self& __x)
00317         { return *(_Self*)&((_default_iterator_base*)this)->operator=(__x); }
00318   };
00319 
00323   typedef _default_iterator<_VDBL_col, const _VDBL_col&, const _VDBL_col*>
00324                                                 default_const_iterator;
00325 
00331   class _col_iterator_base
00332   {
00333   public:
00334     typedef size_t size_type;
00335     typedef ptrdiff_t difference_type;
00336     typedef std::bidirectional_iterator_tag iterator_category;
00337 
00338     _VDBL_tableid _DI_ti;
00339     _VDBL_colid _DI_ci;
00340     _VDBL_rowid _DI_ri;
00341     const _VDBL_view* _DI_v;
00342     void *_DI_data;
00343 
00344     _col_iterator_base(const _VDBL_view* __x, const _VDBL_tableid& __t,
00345                        const _VDBL_rowid& __r, const _VDBL_colid& __c,
00346                        void* __d = NULL)
00347                 : _DI_ti(__t), _DI_ci(__c), _DI_ri(__r), _DI_v(__x),
00348                   _DI_data(__d) {}
00349         
00350     _col_iterator_base() : _DI_ti(), _DI_ci(), _DI_ri(), _DI_v(NULL), 
00351                            _DI_data(NULL) {}
00352 
00353     _col_iterator_base(const _col_iterator_base& _cit) :
00354         _DI_ti(_cit._DI_ti), _DI_ci(_cit._DI_ci), _DI_ri(_cit._DI_ri),
00355         _DI_v(_cit._DI_v)
00356         {
00357           if(_DI_v && _DI_data)
00358             _DI_data = _DI_v->_copy_col_data(_cit._DI_data);
00359           else
00360             _DI_data = NULL;
00361         }
00362 
00363     virtual ~_col_iterator_base()
00364         { if(_DI_v && _DI_data) _DI_v->_destroy_col_data(_DI_data); }
00365 
00366     void _D_incr()
00367         { triple<_VDBL_tableid,_VDBL_colid,void*>
00368                      _x(_DI_v->_next_col(_DI_ti, _DI_ri, _DI_ci, _DI_data));
00369           _DI_ti = _x.first;
00370           _DI_ci = _x.second;
00371           _DI_data = _x.third;
00372         }
00373 
00374     void _D_decr()
00375         { triple<_VDBL_tableid,_VDBL_colid,void*>
00376                      _x(_DI_v->_prev_col(_DI_ti, _DI_ri, _DI_ci, _DI_data));
00377           _DI_ti = _x.first;
00378           _DI_ci = _x.second;
00379           _DI_data = _x.third;
00380         }
00381 
00382     
00383     bool operator==(const _col_iterator_base& __x) const
00384               { return _DI_v == __x._DI_v && _DI_ti == __x._DI_ti &&
00385                        _DI_ri == __x._DI_ri && _DI_ci == __x._DI_ci; }
00386 
00387     bool operator!=(const _col_iterator_base& __x) const
00388               { return _DI_v != __x._DI_v || _DI_ti != __x._DI_ti ||
00389                        _DI_ri != __x._DI_ri || _DI_ci != __x._DI_ci; }
00390 
00391     _col_iterator_base& operator=(const _col_iterator_base& __x)
00392               {
00393                 _DI_v = __x._DI_v; _DI_ti = __x._DI_ti;
00394                 _DI_ri = __x._DI_ri; _DI_ci = __x._DI_ci;
00395                 if(_DI_v && _DI_data) _DI_v->_destroy_col_data(_DI_data);
00396                 if(_DI_v && __x._DI_data)
00397                   _DI_data = _DI_v->_copy_col_data(__x._DI_data);
00398                 else
00399                   _DI_data = NULL;
00400                 return *this;
00401               }
00402   };
00403 
00409   template<typename _Tp, typename _Ref, typename _Ptr>
00410   struct _col_iterator : public _col_iterator_base
00411   {
00412   public:
00413     typedef _col_iterator<_Tp,_Tp&,_Tp*>             iterator;
00414     typedef _col_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00415     typedef _col_iterator<_Tp,_Ref,_Ptr>             _Self;
00416 
00417     typedef _Tp value_type;
00418     typedef _Ptr pointer;
00419     typedef _Ref reference;
00420 
00421     _col_iterator(const _VDBL_view* __x, const _VDBL_tableid& __t,
00422                   const _VDBL_rowid& __r, const _VDBL_colid& __c,
00423                   void *__d = NULL)
00424                                 : _col_iterator_base(__x,__t,__r,__c,__d) { }
00425 
00426     _col_iterator() : _col_iterator_base() { }
00427 
00428     _col_iterator(const iterator& __x)
00429         : _col_iterator_base(__x._DI_v, __x._DI_ti, __x._DI_ri, __x._DI_ci,
00430                              __x._DI_data) { }
00431 
00432     reference operator*() const
00433         {
00434           bool dummy;
00435           return _DI_v->get_raw_col(std::make_pair(_DI_ti, _DI_ri),
00436                                     _DI_ci, dummy);
00437         }
00438 
00439     _VDBL_colid id() const { return _DI_ci; }
00440 
00441     pointer operator->() const { return &(operator*()); }
00442 
00443     _Self& operator++() { this->_D_incr(); return *this; }
00444 
00445     _Self operator++(int)
00446         { _Self __tmp = *this; this->_D_incr(); return __tmp; }
00447 
00448     _Self& operator--() { this->_D_decr(); return *this; }
00449 
00450     _Self operator--(int)
00451         { _Self __tmp = *this; this->_D_decr(); return __tmp; }
00452 
00453     _Self& operator=(const _Self& __x)
00454         { return *(_Self*)&((_col_iterator_base*)this)->operator=(__x); }
00455   };
00456 
00460   typedef _col_iterator<_VDBL_col, const _VDBL_col&, const _VDBL_col*>
00461                                                 col_const_iterator;
00462 
00468   class _row_iterator_base
00469   {
00470   public:
00471     typedef size_t size_type;
00472     typedef ptrdiff_t difference_type;
00473     typedef std::bidirectional_iterator_tag iterator_category;
00474 
00475     _VDBL_tableid _DI_ti;
00476     _VDBL_rowid _DI_ri;
00477     const _VDBL_view* _DI_v;
00478     void* _DI_data;
00479 
00480     _row_iterator_base(const _VDBL_view* __x, const _VDBL_tableid& __t,
00481                        const _VDBL_rowid& __r, void *__d = NULL)
00482                 : _DI_ti(__t), _DI_ri(__r), _DI_v(__x), _DI_data(__d) { }
00483 
00484     _row_iterator_base() : _DI_ti(), _DI_ri(), _DI_v(NULL), _DI_data(NULL) {}
00485 
00486     _row_iterator_base(const _row_iterator_base& _rit) :
00487                         _DI_ti(_rit._DI_ti), _DI_ri(_rit._DI_ri),
00488                         _DI_v(_rit._DI_v), _DI_data(_rit._DI_data)
00489         {
00490           if(_DI_v && _DI_data)
00491             _DI_data = _DI_v->_copy_row_data(_rit._DI_data);
00492           else
00493             _DI_data = NULL;
00494         }
00495 
00496     virtual ~_row_iterator_base()
00497         { if(_DI_v && _DI_data) _DI_v->_destroy_row_data(_DI_data); }
00498 
00499     void _D_incr()
00500         { triple<_VDBL_tableid,_VDBL_rowid,void*>
00501                             _x(_DI_v->_next_row(_DI_ti, _DI_ri, _DI_data));
00502           _DI_ti = _x.first;
00503           _DI_ri = _x.second;
00504           _DI_data = _x.third;
00505         }
00506 
00507     void _D_decr()
00508         { triple<_VDBL_tableid,_VDBL_rowid,void*>
00509                             _x(_DI_v->_prev_row(_DI_ti, _DI_ri, _DI_data));
00510           _DI_ti = _x.first;
00511           _DI_ri = _x.second;
00512           _DI_data = _x.third;
00513         }
00514 
00515     
00516     bool operator==(const _row_iterator_base& __x) const
00517               { return _DI_v == __x._DI_v && _DI_ti == __x._DI_ti &&
00518                        _DI_ri == __x._DI_ri; }
00519 
00520     bool operator!=(const _row_iterator_base& __x) const
00521               { return _DI_v != __x._DI_v || _DI_ti != __x._DI_ti ||
00522                        _DI_ri != __x._DI_ri; }
00523 
00524     _row_iterator_base& operator=(const _row_iterator_base& __x)
00525               {
00526                 _DI_v = __x._DI_v; _DI_ti = __x._DI_ti; _DI_ri = __x._DI_ri;
00527                 if(_DI_v && _DI_data) _DI_v->_destroy_row_data(_DI_data);
00528                 if(_DI_v && __x._DI_data)
00529                   _DI_data = _DI_v->_copy_row_data(__x._DI_data);
00530                 else
00531                   _DI_data = NULL;
00532                 return *this;
00533               }
00534   };
00535 
00541   template<typename _Tp, typename _Ref, typename _Ptr>
00542   struct _row_iterator : public _row_iterator_base
00543   {
00544   public:
00545     typedef _row_iterator<_Tp,_Tp&,_Tp*>             iterator;
00546     typedef _row_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00547     typedef _row_iterator<_Tp,_Ref,_Ptr>             _Self;
00548 
00549     typedef _Tp value_type;
00550     typedef _Ptr pointer;
00551     typedef _Ref reference;
00552 
00553     _row_iterator(const _VDBL_view* __x, const _VDBL_tableid& __t,
00554                   const _VDBL_rowid& __r, void *__d = NULL)
00555                                 : _row_iterator_base(__x,__t,__r,__d) { }
00556 
00557     _row_iterator() : _row_iterator_base() { }
00558 
00559     _row_iterator(const iterator& __x)
00560       : _row_iterator_base(__x._DI_v, __x._DI_ti, __x._DI_ri, __x._DI_data) { }
00561 
00562     reference operator*() const
00563         {
00564           bool dummy;
00565           return _DI_v->get_row(std::make_pair(_DI_ti, _DI_ri), dummy);
00566         }
00567 
00568     _VDBL_rowid id() const { return _DI_ri; }
00569 
00570     pointer operator->() const { return &(operator*()); }
00571 
00572     _Self& operator++() { this->_D_incr(); return *this; }
00573 
00574     _Self operator++(int)
00575         { _Self __tmp = *this; this->_D_incr(); return __tmp; }
00576 
00577     _Self& operator--() { this->_D_decr(); return *this; }
00578 
00579     _Self operator--(int)
00580         { _Self __tmp = *this; this->_D_decr(); return __tmp; }
00581 
00582     _Self& operator=(const _Self& __x)
00583         { return *(_Self*)&((_row_iterator_base*)this)->operator=(__x); }
00584   };
00585 
00589   typedef _row_iterator<_VDBL_row, const _VDBL_row&, const _VDBL_row*>
00590                                                 row_const_iterator;
00591 
00592 public:
00596   _VDBL_view(_V_enum __e = V_independent) : _V_e(__e), change_ctr(0) {}
00600   _VDBL_view(const _VDBL_view& __v) : _V_e(__v._V_e), change_ctr(0) {}
00604   virtual ~_VDBL_view() {}
00605 
00613   virtual const std::type_info& get_colinfo(const std::string& _C_n,
00614                 triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
00615         VDBL_PURE_VIRTUAL
00616 
00622   virtual bool insert(const std::vector<_T_colspec>& _row) VDBL_PURE_VIRTUAL
00623 
00627   virtual bool remove(std::pair<_VDBL_tableid,_VDBL_rowid>) VDBL_PURE_VIRTUAL
00628 
00632   virtual bool has_col(const std::string& _C_n) const VDBL_PURE_VIRTUAL
00633 
00637   virtual std::pair<_VDBL_tableid,_VDBL_colid> get_col_id(
00638                               const std::string& _C_n) const VDBL_PURE_VIRTUAL
00639 
00646   virtual const _VDBL_col& get_raw_col(
00647                    const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00648                    const _VDBL_colid& _ci, _VDBL_row const *& _rr,
00649                    bool& error) const VDBL_PURE_VIRTUAL
00650 
00656   virtual std::ostream& print_col(std::ostream& o,
00657                  const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00658                  const _VDBL_colid& _ci, bool& printed) const VDBL_PURE_VIRTUAL
00659 
00665   virtual const _VDBL_row& get_row(
00666                          const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00667                          bool& error) const VDBL_PURE_VIRTUAL
00668 
00674   virtual const _VDBL_col& get_def(
00675                          const std::pair<_VDBL_tableid,_VDBL_colid>& _ri,
00676                          bool& error) const VDBL_PURE_VIRTUAL
00677 
00681   virtual default_const_iterator defaults_begin() const VDBL_PURE_VIRTUAL
00682 
00686   virtual default_const_iterator defaults_end() const VDBL_PURE_VIRTUAL
00687 
00691   virtual row_const_iterator rows_begin() const VDBL_PURE_VIRTUAL
00692 
00696   virtual row_const_iterator rows_end() const VDBL_PURE_VIRTUAL
00697 
00701   virtual col_const_iterator cols_begin(const _VDBL_rowid& _r) const VDBL_PURE_VIRTUAL
00702 
00706   virtual col_const_iterator cols_end(const _VDBL_rowid& _r) const VDBL_PURE_VIRTUAL
00707 
00711   _V_enum view_type() const { return _V_e; }
00712 };
00713 
00714 typedef _VDBL_view viewbase;
00715 
00716 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00717 #pragma reset woff 1209
00718 #endif
00719 
00720 __VDBL_END_NAMESPACE
00721 
00722 #endif /* __VDBL_VIEW_H */
00723 
00724 // Local Variables:
00725 // mode:C++
00726 // End: