Vienna Database Library: vdbl_listindex.h Source File

00001 // List Index class implementation -*- C++ -*-
00002 
00003 // $Id: vdbl_index.h 347 2008-02-06 15:20:01Z schilly $
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_LISTINDEX_H
00032 #define __VDBL_LISTINDEX_H
00033 
00034 #include <map>
00035 #include <list>
00036 #include <vdbl_index.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 
00044 template <class _TR>
00045 class _VDBL_index_l : public __VDBL_index
00046 {
00047 private:
00048   typedef _TR type_t;
00049   typedef std::list<std::pair<type_t, _VDBL_rowid> > idx_t;
00050   typedef std::map<_VDBL_rowid, typename idx_t::iterator> itt_t;
00051 
00052   idx_t i;
00053   itt_t m;
00054 
00055   _VDBL_colid c;
00056 
00057 private:
00058   virtual bool ins(const type_t* T, const _VDBL_rowid rid)
00059     {
00060       typename idx_t::iterator i_it;
00061  
00062       i_it = std::upper_bound(i.begin(), i.end(), *T);
00063       i.insert(i_it, std::make_pair(*T, rid));
00064       m[rid] = i_it;
00065       return true;
00066     }
00067 
00068 public:
00069   _VDBL_index_l(_VDBL_colid __c) : i(), m(), c(__c) {}
00070   virtual ~_VDBL_index_l() {}
00071 
00072   virtual VDBL_index_type type() const { return vdbl_list_index; }
00073 
00074   virtual void destroy() { clear(); }
00075   virtual bool clear() { i.clear(); return true; }
00076 
00077   virtual bool del(const _VDBL_rowid rid)
00078     {
00079       typename itt_t::iterator i_it;
00080       i_it = m.find(rid);
00081       if(i_it == m.end())
00082         return false;
00083       i.erase((*i_it).second);
00084       m.erase(i_it);
00085       return true;
00086     }
00087   
00088   virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
00089     {
00090       bool error;
00091       const _VDBL_col& _c(_r.get_col(c, error));
00092       if(error)
00093         return false;
00094       else
00095       {
00096         const type_t *T;
00097         _c.get_ptr(T);
00098         return ins(T, rid);
00099       }
00100     }
00101 
00102   virtual bool maximal(_VDBL_rowid& r) const
00103     {
00104       typename idx_t::const_iterator i_it(i.end());
00105       if(i_it != i.begin())
00106       {
00107         --i_it;
00108         r = (*i_it).second;
00109         return true;
00110       }
00111       else
00112         return false;
00113     }
00114 
00115   virtual bool minimal(_VDBL_rowid& r) const
00116     {
00117       typename idx_t::const_iterator i_it(i.begin());
00118       if(i_it != i.end())
00119       {
00120         r = (*i_it).second;
00121         return true;
00122       }
00123       else
00124         return false;
00125     }
00126 
00127   virtual bool maximal(std::list<_VDBL_rowid>& _Ct) const
00128     {
00129       typename idx_t::const_iterator i_it(i.end());
00130       type_t _T;
00131       if(i_it != i.begin())
00132       {
00133         --i_it;
00134         _T = (*i_it).first;
00135         _Ct.push_back((*i_it).second);
00136         while(i_it != i.begin())
00137         {
00138           --i_it;
00139           if(_T != (*i_it).first)
00140             break;
00141           _Ct.push_back((*i_it).second);
00142         }
00143         return true;
00144       }
00145       else
00146         return false;
00147     }
00148 
00149   virtual bool minimal(std::list<_VDBL_rowid>& _Ct) const
00150     {
00151       typename idx_t::const_iterator i_it(i.begin());
00152       type_t _T;
00153       if(i_it != i.end())
00154       {
00155         _T = (*i_it).first;
00156         _Ct.push_back((*i_it).second);
00157         while(i_it != i.end())
00158         {
00159           ++i_it;
00160           if(_T != (*i_it).first)
00161             break;
00162           _Ct.push_back((*i_it).second);
00163         }
00164         return true;
00165       }
00166       else
00167         return false;
00168     }
00169 
00170   virtual bool getval(const void* c, const std::type_info& tinfo, _VDBL_rowid& r) const
00171     {
00172       if(tinfo != typeid(type_t))
00173         return false;
00174       const type_t *T((const type_t *)c);
00175       
00176       typename idx_t::iterator i_it;
00177       i_it = std::lower_bound(i.begin(), i.end(), *T);
00178       if(i_it == i.end())
00179         return false;
00180       if((*i_it).first != *T)
00181         return false;
00182       r = (*i_it).second;
00183       return true;
00184     }
00185 
00186   virtual bool getval(const void* c, const std::type_info& tinfo, std::list<_VDBL_rowid>& _Ct) const
00187     {
00188       if(tinfo != typeid(type_t))
00189         return false;
00190       const type_t *T((const type_t *)c);
00191       bool found(false);
00192       
00193       std::pair<typename idx_t::iterator, typename idx_t::iterator> i_it;
00194       i_it = std::equal_range(i.begin(), i.end(), *T);
00195       while(i_it.first != i_it.second)
00196       {
00197         _Ct.push_back((*i_it.first).second);
00198         found = true;
00199       }
00200       return found;
00201     }
00202 };
00203 
00204 template <class _TR>
00205 class list_index : public _VDBL_index_l<_TR>
00206 {
00207 private:
00208   typedef _VDBL_index_l<_TR> _Base;
00209 
00210 public: 
00211   list_index() {}
00212   virtual ~list_index() {}
00213 
00214 public:
00215   virtual VDBL_index_type type() const { return _Base::type(); }
00216 
00217   virtual void destroy() { _Base::destroy(); }
00218 
00219   virtual bool clear() { return _Base::clear(); }
00220   virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
00221      { return _Base::ins(_r, rid); }
00222   virtual bool del(const _VDBL_rowid rid)
00223      { return _Base::del(rid); }
00224 
00225   virtual bool maximal(_VDBL_rowid& r) const
00226      { return _Base::maximal(r); }
00227   virtual bool minimal(_VDBL_rowid& r) const
00228      { return _Base::minimal(r); }
00229 
00230   virtual bool maximal(std::list<_VDBL_rowid>& _Ct) const
00231      { return _Base::maximal(_Ct); }
00232   virtual bool minimal(std::list<_VDBL_rowid>& _Ct) const
00233      { return _Base::minimal(_Ct); }
00234 
00235   virtual bool getval(const void* c, const std::type_info& t, _VDBL_rowid& r) const
00236      { return _Base::getval(c, t, r); }
00237   virtual bool getval(const void* c, const std::type_info& t, std::list<_VDBL_rowid>& _Ct) const
00238      { return _Base::getval(c, t, _Ct); }
00239 };
00240 
00241 template <class _TR>
00242 class list_index_def : public _VDBL_index_l<_TR>
00243 {
00244 private:
00245   typedef _VDBL_index_l<_TR> _Base;
00246   typedef _TR type_t;
00247 
00248   type_t default_value;
00249 
00250 public: 
00251   list_index_def(const type_t& __d) : _Base(), default_value(__d) {}
00252   virtual ~list_index_def() {}
00253 
00254 public:
00255   virtual VDBL_index_type type() const { return _Base::type(); }
00256 
00257   virtual void destroy() { _Base::destroy(); }
00258 
00259   virtual bool clear() { return _Base::clear(); }
00260 
00261   virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
00262     {
00263       bool error;
00264       const _VDBL_col& _c(_r.get_col(this->c, error));
00265       if(error)
00266         return ins(&default_value, rid);
00267       else
00268       {
00269         const type_t *T;
00270         _c.get_ptr(T);
00271         return ins(T, rid);
00272       }
00273     }
00274 
00275   virtual bool del(const _VDBL_rowid rid)
00276      { return _Base::del(rid); }
00277 
00278   virtual bool maximal(_VDBL_rowid& r) const
00279      { return _Base::maximal(r); }
00280   virtual bool minimal(_VDBL_rowid& r) const
00281      { return _Base::minimal(r); }
00282 
00283   virtual bool maximal(std::list<_VDBL_rowid>& _Ct) const
00284      { return _Base::maximal(_Ct); }
00285   virtual bool minimal(std::list<_VDBL_rowid>& _Ct) const
00286      { return _Base::minimal(_Ct); }
00287 
00288   virtual bool getval(const void* c, const std::type_info& t, _VDBL_rowid& r) const
00289      { return _Base::getval(c, t, r); }
00290   virtual bool getval(const void* c, const std::type_info& t, std::list<_VDBL_rowid>& _Ct) const
00291      { return _Base::getval(c, t, _Ct); }
00292 };
00293 
00294 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
00295 #pragma reset woff 1209
00296 #endif
00297 
00298 __VDBL_END_NAMESPACE
00299 
00300 #endif /* __VDBL_LISTINDEX_H */
00301 
00302 // Local Variables:
00303 // mode:C++
00304 // End: