Vienna Database Library: vdbl

00001 // $Id: vdbl_view.h 634 2008-05-20 14:28:14Z herman $
00002 // Copyright (C) 2003 Hermann Schichl
00003 //
00004 // This file is part of the Vienna Database Library.  This library is free
00005 // software; you can redistribute it and/or modify it under the
00006 // terms of the Library GNU General Public License as published by the
00007 // Free Software Foundation; either version 2, or (at your option)
00008 // any later version.
00009 
00010 // This library is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // Library GNU General Public License for more details.
00014 
00015 // As a special exception, you may use this file as part of a free software
00016 // library without restriction.  Specifically, if other files instantiate
00017 // templates or use macros or inline functions from this file, or you compile
00018 // this file and link it with other files to produce an executable, this
00019 // file does not by itself cause the resulting executable to be covered by
00020 // the Library GNU General Public License.  This exception does not however
00021 // invalidate any other reasons why the executable file might be covered by
00022 // the Library GNU General Public License.
00023 
00029 #ifndef __VDBL_VIEW_H
00030 #define __VDBL_VIEW_H
00031 
00032 #include <algorithm>
00033 #include <map>
00034 #include <vector>
00035 #include <typeinfo>
00036 #include <triple>
00037 #include <vdbl_table.h>
00038 #include <vdbl_config.h>
00039 #include <vdbl_types.h>
00040 
00041 __VDBL_BEGIN_NAMESPACE
00042 
00043 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00044 #pragma set woff 1209
00045 #endif
00046 
00047 class _VDBL_table;
00048 
00050 
00055 class _VDBL_view
00056 {
00057 public:
00061   typedef std::pair<std::string,_VDBL_col> _T_colspec;
00062 
00063 private:
00065   _V_enum _V_e;
00067   unsigned int change_ctr;
00068 
00069 protected:
00070   
00072   void made_change() { change_ctr++; }
00074   unsigned int get_change_ctr() const { return change_ctr; }
00075 
00081   virtual std::triple<_VDBL_tableid,_VDBL_colid,void*>
00082         _next_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
00083                       void* _d) const
00084                 VDBL_PURE_VIRTUAL
00085 
00091   virtual std::triple<_VDBL_tableid,_VDBL_colid,void*>
00092         _prev_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
00093                       void* _d) const
00094                 VDBL_PURE_VIRTUAL
00095 
00100   virtual void _destroy_def_data(void*& _d) const {}
00101 
00106   virtual void* _copy_def_data(void* _d) const VDBL_PURE_VIRTUAL
00107 
00113   virtual std::triple<_VDBL_tableid,_VDBL_colid,void*>
00114         _next_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00115                   const _VDBL_colid& _c, void* _d) const
00116                 VDBL_PURE_VIRTUAL
00117 
00123   virtual std::triple<_VDBL_tableid,_VDBL_colid,void*>
00124         _prev_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
00125                   const _VDBL_colid& _c, void* _d) const
00126                 VDBL_PURE_VIRTUAL
00127 
00132   virtual void _destroy_col_data(void*& _d) const {}
00133 
00138   virtual void* _copy_col_data(void* _d) const VDBL_PURE_VIRTUAL
00139 
00145   virtual std::triple<_VDBL_tableid,_VDBL_rowid,void*>
00146         _next_row(const _VDBL_tableid& _t, const _VDBL_rowid& _c,
00147                       void* _d) const
00148                 VDBL_PURE_VIRTUAL
00149 
00155   virtual std::triple<_VDBL_tableid,_VDBL_rowid,void*>
00156         _prev_row(const _VDBL_tableid& _t, const _VDBL_rowid& _c,
00157                       void* _d) const
00158                 VDBL_PURE_VIRTUAL
00159 
00164   virtual void _destroy_row_data(void*& _d) const {}
00165 
00170   virtual void* _copy_row_data(void* _d) const VDBL_PURE_VIRTUAL
00171 
00172 public:
00178   class _default_iterator_base
00179   {
00180   public:
00181     typedef size_t size_type;
00182     typedef ptrdiff_t difference_type;
00183     typedef std::bidirectional_iterator_tag iterator_category;
00184 
00185     _VDBL_tableid _DI_ti;
00186     _VDBL_colid _DI_ci;
00187     const _VDBL_view* _DI_v;
00188     void* _DI_data;
00189 
00190     _default_iterator_base(const _VDBL_view* __x, const _VDBL_tableid& __t,
00191                            const _VDBL_colid& __c, void *__data = NULL)
00192                 : _DI_ti(__t), _DI_ci(__c), _DI_v(__x), _DI_data(__data) { }
00193 
00194     _default_iterator_base() : _DI_ti(),_DI_ci(),_DI_v(NULL),_DI_data(NULL) {}
00195 
00196     _default_iterator_base(const _default_iterator_base& _dib)
00197         : _DI_ti(_dib._DI_ti),_DI_ci(_dib._DI_ci),_DI_v(_dib._DI_v)
00198         {
00199           if(_DI_v && _DI_data)
00200             _DI_data = _DI_v->_copy_def_data(_dib._DI_data);
00201           else
00202             _DI_data = NULL;
00203         }
00204 
00205     virtual ~_default_iterator_base()
00206         { if(_DI_v && _DI_data) _DI_v->_destroy_def_data(_DI_data); }
00207 
00208     void _D_incr()
00209         { std::triple<_VDBL_tableid,_VDBL_colid,void*>
00210                            _x(_DI_v->_next_def_col(_DI_ti, _DI_ci, _DI_data));
00211           _DI_ti = _x.first;
00212           _DI_ci = _x.second;
00213           _DI_data = _x.third;
00214         }
00215 
00216     void _D_decr()
00217         { std::triple<_VDBL_tableid,_VDBL_colid,void*>
00218                            _x(_DI_v->_prev_def_col(_DI_ti, _DI_ci, _DI_data));
00219           _DI_ti = _x.first;
00220           _DI_ci = _x.second;
00221           _DI_data = _x.third;
00222         }
00223 
00224     
00225     bool operator==(const _default_iterator_base& __x) const
00226               { return _DI_v == __x._DI_v && _DI_ti == __x._DI_ti &&
00227                        _DI_ci == __x._DI_ci; }
00228 
00229     bool operator!=(const _default_iterator_base& __x) const
00230               { return _DI_v != __x._DI_v || _DI_ti != __x._DI_ti ||
00231                        _DI_ci != __x._DI_ci; }
00232 
00233     _default_iterator_base& operator=(const _default_iterator_base& __x)
00234               {
00235                 _DI_v = __x._DI_v; _DI_ti = __x._DI_ti; _DI_ci = __x._DI_ci;
00236                 if(_DI_v && _DI_data) _DI_v->_destroy_def_data(_DI_data);
00237                 if(_DI_v && __x._DI_data)
00238                   _DI_data = _DI_v->_copy_def_data(__x._DI_data);
00239                 else
00240                   _DI_data = NULL;
00241                 return *this;
00242               }
00243   };
00244 
00250   template<typename _Tp, typename _Ref, typename _Ptr>
00251   struct _default_iterator : public _default_iterator_base
00252   {
00253   public:
00254     typedef _default_iterator<_Tp,_Tp&,_Tp*>             iterator;
00255     typedef _default_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00256     typedef _default_iterator<_Tp,_Ref,_Ptr>             _Self;
00257 
00258     typedef _Tp value_type;
00259     typedef _Ptr pointer;
00260     typedef _Ref reference;
00261 
00262     _default_iterator(const _VDBL_view* __x, const _VDBL_tableid& __t,
00263                       const _VDBL_colid& __c, void *__d = NULL)
00264                                 : _default_iterator_base(__x,__t,__c,__d) { }
00265 
00266     _default_iterator() : _default_iterator_base() { }
00267 
00268     _default_iterator(const iterator& __x)
00269         : _default_iterator_base(__x._DI_v, __x._DI_ti, __x._DI_ci,
00270                                  __x._DI_data) { }
00271 
00272     reference operator*() const
00273         {
00274           bool dummy;
00275           return _DI_v->get_def(std::make_pair(_DI_ti, _DI_ci), dummy);
00276         }
00277 
00278     _VDBL_colid id() const { return _DI_ci; }
00279     _VDBL_tableid tid() const { return _DI_ti; }
00280 
00281     pointer operator->() const { return &(operator*()); }
00282 
00283     _Self& operator++() { this->_D_incr(); return *this; }
00284 
00285     _Self operator++(int)
00286         { _Self __tmp = *this; this->_D_incr(); return __tmp; }
00287 
00288     _Self& operator--() { this->_D_decr(); return *this; }
00289 
00290     _Self operator--(int)
00291         { _Self __tmp = *this; this->_D_decr(); return __tmp; }
00292 
00293     _Self& operator=(const _Self& __x)
00294         { return *(_Self*)&((_default_iterator_base*)this)->operator=(__x); }
00295   };
00296 
00300   typedef _default_iterator<_VDBL_col, const _VDBL_col&, const _VDBL_col*>
00301                                                 default_const_iterator;
00302 
00308   class _col_iterator_base
00309   {
00310   public:
00311     typedef size_t size_type;
00312     typedef ptrdiff_t difference_type;
00313     typedef std::bidirectional_iterator_tag iterator_category;
00314 
00315     _VDBL_tableid _DI_ti;
00316     _VDBL_colid _DI_ci;
00317     _VDBL_rowid _DI_ri;
00318     const _VDBL_view* _DI_v;
00319     void *_DI_data;
00320 
00321     _col_iterator_base(const _VDBL_view* __x, const _VDBL_tableid& __t,
00322                        const _VDBL_rowid& __r, const _VDBL_colid& __c,
00323                        void* __d = NULL)
00324                 : _DI_ti(__t), _DI_ci(__c), _DI_ri(__r), _DI_v(__x),
00325                   _DI_data(__d) {}
00326         
00327     _col_iterator_base() : _DI_ti(), _DI_ci(), _DI_ri(), _DI_v(NULL), 
00328                            _DI_data(NULL) {}
00329 
00330     _col_iterator_base(const _col_iterator_base& _cit) :
00331         _DI_ti(_cit._DI_ti), _DI_ci(_cit._DI_ci), _DI_ri(_cit._DI_ri),
00332         _DI_v(_cit._DI_v)
00333         {
00334           if(_DI_v && _DI_data)
00335             _DI_data = _DI_v->_copy_col_data(_cit._DI_data);
00336           else
00337             _DI_data = NULL;
00338         }
00339 
00340     virtual ~_col_iterator_base()
00341         { if(_DI_v && _DI_data) _DI_v->_destroy_col_data(_DI_data); }
00342 
00343     void _D_incr()
00344         { std::triple<_VDBL_tableid,_VDBL_colid,void*>
00345                      _x(_DI_v->_next_col(_DI_ti, _DI_ri, _DI_ci, _DI_data));
00346           _DI_ti = _x.first;
00347           _DI_ci = _x.second;
00348           _DI_data = _x.third;
00349         }
00350 
00351     void _D_decr()
00352         { std::triple<_VDBL_tableid,_VDBL_colid,void*>
00353                      _x(_DI_v->_prev_col(_DI_ti, _DI_ri, _DI_ci, _DI_data));
00354           _DI_ti = _x.first;
00355           _DI_ci = _x.second;
00356           _DI_data = _x.third;
00357         }
00358 
00359     
00360     bool operator==(const _col_iterator_base& __x) const
00361               { return _DI_v == __x._DI_v && _DI_ti == __x._DI_ti &&
00362                        _DI_ri == __x._DI_ri && _DI_ci == __x._DI_ci; }
00363 
00364     bool operator!=(const _col_iterator_base& __x) const
00365               { return _DI_v != __x._DI_v || _DI_ti != __x._DI_ti ||
00366                        _DI_ri != __x._DI_ri || _DI_ci != __x._DI_ci; }
00367 
00368     _col_iterator_base& operator=(const _col_iterator_base& __x)
00369               {
00370                 _DI_v = __x._DI_v; _DI_ti = __x._DI_ti;
00371                 _DI_ri = __x._DI_ri; _DI_ci = __x._DI_ci;
00372                 if(_DI_v && _DI_data) _DI_v->_destroy_col_data(_DI_data);
00373                 if(_DI_v && __x._DI_data)
00374                   _DI_data = _DI_v->_copy_col_data(__x._DI_data);
00375                 else
00376                   _DI_data = NULL;
00377                 return *this;
00378               }
00379   };
00380 
00386   template<typename _Tp, typename _Ref, typename _Ptr>
00387   struct _col_iterator : public _col_iterator_base
00388   {
00389   public:
00390     typedef _col_iterator<_Tp,_Tp&,_Tp*>             iterator;
00391     typedef _col_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00392     typedef _col_iterator<_Tp,_Ref,_Ptr>             _Self;
00393 
00394     typedef _Tp value_type;
00395     typedef _Ptr pointer;
00396     typedef _Ref reference;
00397 
00398     _col_iterator(const _VDBL_view* __x, const _VDBL_tableid& __t,
00399                   const _VDBL_rowid& __r, const _VDBL_colid& __c,
00400                   void *__d = NULL)
00401                                 : _col_iterator_base(__x,__t,__r,__c,__d) { }
00402 
00403     _col_iterator() : _col_iterator_base() { }
00404 
00405     _col_iterator(const iterator& __x)
00406         : _col_iterator_base(__x._DI_v, __x._DI_ti, __x._DI_ri, __x._DI_ci,
00407                              __x._DI_data) { }
00408 
00409     reference operator*() const
00410         {
00411           bool dummy;
00412           const _VDBL_row* dr;
00413           return _DI_v->get_raw_col(std::make_pair(_DI_ti, _DI_ri),
00414                                     _DI_ci, dr, dummy);
00415         }
00416 
00417     _VDBL_colid id() const { return _DI_ci; }
00418 
00419     pointer operator->() const { return &(operator*()); }
00420 
00421     _Self& operator++() { this->_D_incr(); return *this; }
00422 
00423     _Self operator++(int)
00424         { _Self __tmp = *this; this->_D_incr(); return __tmp; }
00425 
00426     _Self& operator--() { this->_D_decr(); return *this; }
00427 
00428     _Self operator--(int)
00429         { _Self __tmp = *this; this->_D_decr(); return __tmp; }
00430 
00431     _Self& operator=(const _Self& __x)
00432         { return *(_Self*)&((_col_iterator_base*)this)->operator=(__x); }
00433   };
00434 
00438   typedef _col_iterator<_VDBL_col, const _VDBL_col&, const _VDBL_col*>
00439                                                 col_const_iterator;
00440 
00446   class _row_iterator_base
00447   {
00448   public:
00449     typedef size_t size_type;
00450     typedef ptrdiff_t difference_type;
00451     typedef std::bidirectional_iterator_tag iterator_category;
00452 
00453     _VDBL_tableid _DI_ti;
00454     _VDBL_rowid _DI_ri;
00455     const _VDBL_view* _DI_v;
00456     void* _DI_data;
00457 
00458     _row_iterator_base(const _VDBL_view* __x, const _VDBL_tableid& __t,
00459                        const _VDBL_rowid& __r, void *__d = NULL)
00460                 : _DI_ti(__t), _DI_ri(__r), _DI_v(__x), _DI_data(__d) { }
00461 
00462     _row_iterator_base() : _DI_ti(), _DI_ri(), _DI_v(NULL), _DI_data(NULL) {}
00463 
00464     _row_iterator_base(const _row_iterator_base& _rit) :
00465                         _DI_ti(_rit._DI_ti), _DI_ri(_rit._DI_ri),
00466                         _DI_v(_rit._DI_v), _DI_data(_rit._DI_data)
00467         {
00468           if(_DI_v && _DI_data)
00469             _DI_data = _DI_v->_copy_row_data(_rit._DI_data);
00470           else
00471             _DI_data = NULL;
00472         }
00473 
00474     virtual ~_row_iterator_base()
00475         { if(_DI_v && _DI_data) _DI_v->_destroy_row_data(_DI_data); }
00476 
00477     void _D_incr()
00478         { std::triple<_VDBL_tableid,_VDBL_rowid,void*>
00479                             _x(_DI_v->_next_row(_DI_ti, _DI_ri, _DI_data));
00480           _DI_ti = _x.first;
00481           _DI_ri = _x.second;
00482           _DI_data = _x.third;
00483         }
00484 
00485     void _D_decr()
00486         { std::triple<_VDBL_tableid,_VDBL_rowid,void*>
00487                             _x(_DI_v->_prev_row(_DI_ti, _DI_ri, _DI_data));
00488           _DI_ti = _x.first;
00489           _DI_ri = _x.second;
00490           _DI_data = _x.third;
00491         }
00492 
00493     
00494     bool operator==(const _row_iterator_base& __x) const
00495               { return _DI_v == __x._DI_v && _DI_ti == __x._DI_ti &&
00496                        _DI_ri == __x._DI_ri; }
00497 
00498     bool operator!=(const _row_iterator_base& __x) const
00499               { return _DI_v != __x._DI_v || _DI_ti != __x._DI_ti ||
00500                        _DI_ri != __x._DI_ri; }
00501 
00502     _row_iterator_base& operator=(const _row_iterator_base& __x)
00503               {
00504                 _DI_v = __x._DI_v; _DI_ti = __x._DI_ti; _DI_ri = __x._DI_ri;
00505                 if(_DI_v && _DI_data) _DI_v->_destroy_row_data(_DI_data);
00506                 if(_DI_v && __x._DI_data)
00507                   _DI_data = _DI_v->_copy_row_data(__x._DI_data);
00508                 else
00509                   _DI_data = NULL;
00510                 return *this;
00511               }
00512   };
00513 
00519   template<typename _Tp, typename _Ref, typename _Ptr>
00520   struct _row_iterator : public _row_iterator_base
00521   {
00522   public:
00523     typedef _row_iterator<_Tp,_Tp&,_Tp*>             iterator;
00524     typedef _row_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00525     typedef _row_iterator<_Tp,_Ref,_Ptr>             _Self;
00526 
00527     typedef _Tp value_type;
00528     typedef _Ptr pointer;
00529     typedef _Ref reference;
00530 
00531     _row_iterator(const _VDBL_view* __x, const _VDBL_tableid& __t,
00532                   const _VDBL_rowid& __r, void *__d = NULL)
00533                                 : _row_iterator_base(__x,__t,__r,__d) { }
00534 
00535     _row_iterator() : _row_iterator_base() { }
00536 
00537     _row_iterator(const iterator& __x)
00538       : _row_iterator_base(__x._DI_v, __x._DI_ti, __x._DI_ri, __x._DI_data) { }
00539 
00540     reference operator*() const
00541         {
00542           bool dummy;
00543           return _DI_v->get_row(std::make_pair(_DI_ti, _DI_ri), dummy);
00544         }
00545 
00546     _VDBL_rowid id() const { return _DI_ri; }
00547 
00548     pointer operator->() const { return &(operator*()); }
00549 
00550     _Self& operator++() { this->_D_incr(); return *this; }
00551 
00552     _Self operator++(int)
00553         { _Self __tmp = *this; this->_D_incr(); return __tmp; }
00554 
00555     _Self& operator--() { this->_D_decr(); return *this; }
00556 
00557     _Self operator--(int)
00558         { _Self __tmp = *this; this->_D_decr(); return __tmp; }
00559 
00560     _Self& operator=(const _Self& __x)
00561         { return *(_Self*)&((_row_iterator_base*)this)->operator=(__x); }
00562   };
00563 
00567   typedef _row_iterator<_VDBL_row, const _VDBL_row&, const _VDBL_row*>
00568                                                 row_const_iterator;
00569 
00570 public:
00574   _VDBL_view(_V_enum __e = V_independent) : _V_e(__e), change_ctr(0) {}
00578   _VDBL_view(const _VDBL_view& __v) : _V_e(__v._V_e), change_ctr(0) {}
00582   virtual ~_VDBL_view() {}
00583 
00587   virtual _VDBL_view *new_copy() VDBL_PURE_VIRTUAL
00591   virtual void destroy_copy(_VDBL_view* v) VDBL_PURE_VIRTUAL
00592 
00600   virtual const std::type_info& get_colinfo(const std::string& _C_n,
00601                 std::triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
00602         VDBL_PURE_VIRTUAL
00603 
00607   virtual const std::type_info& get_coltype(const std::string& _C_n) const
00608         VDBL_PURE_VIRTUAL
00609 
00615   virtual bool insert(const std::vector<_T_colspec>& _row) VDBL_PURE_VIRTUAL
00616 
00620   virtual bool remove(std::pair<_VDBL_tableid,_VDBL_rowid>) VDBL_PURE_VIRTUAL
00621 
00625   virtual bool has_col(const std::string& _C_n) const VDBL_PURE_VIRTUAL
00626 
00630   virtual std::pair<_VDBL_tableid,_VDBL_colid> get_col_id(
00631                               const std::string& _C_n) const VDBL_PURE_VIRTUAL
00632 
00636   virtual std::string get_col_name(const _VDBL_colid& _C_n) const VDBL_PURE_VIRTUAL
00637 
00644   virtual const _VDBL_col& get_raw_col(
00645                    const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00646                    const _VDBL_colid& _ci, _VDBL_row const * & _rr,
00647                    bool& error) const VDBL_PURE_VIRTUAL
00648 
00652   virtual bool add_visible(const std::vector<_VDBL_rowid>& _rs)
00653                 VDBL_PURE_VIRTUAL
00654 
00659   virtual bool rm_visible(const std::vector<_VDBL_rowid>& _rs)
00660                 VDBL_PURE_VIRTUAL
00661   
00667   virtual std::ostream& print_col(std::ostream& o,
00668                  const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00669                  const _VDBL_colid& _ci, bool& printed) const VDBL_PURE_VIRTUAL
00670 
00676   virtual const _VDBL_row& get_row(
00677                          const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
00678                          bool& error) const VDBL_PURE_VIRTUAL
00679 
00685   virtual const _VDBL_col& get_def(
00686                          const std::pair<_VDBL_tableid,_VDBL_colid>& _ri,
00687                          bool& error) const VDBL_PURE_VIRTUAL
00688 
00692   virtual default_const_iterator defaults_begin() const VDBL_PURE_VIRTUAL
00693 
00697   virtual default_const_iterator defaults_end() const VDBL_PURE_VIRTUAL
00698 
00702   virtual row_const_iterator rows_begin() const VDBL_PURE_VIRTUAL
00703 
00707   virtual row_const_iterator rows_end() const VDBL_PURE_VIRTUAL
00708 
00712   virtual col_const_iterator cols_begin(const _VDBL_rowid& _r) const VDBL_PURE_VIRTUAL
00713 
00717   virtual col_const_iterator cols_end(const _VDBL_rowid& _r) const VDBL_PURE_VIRTUAL
00718 
00722   _V_enum view_type() const { return _V_e; }
00723 };
00724 
00725 typedef _VDBL_view viewbase;
00726 
00727 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00728 #pragma reset woff 1209
00729 #endif
00730 
00731 __VDBL_END_NAMESPACE
00732 
00733 #endif /* __VDBL_VIEW_H */
00734 
00735 // Local Variables:
00736 // mode:C++
00737 // End: