vdbl_index.h

Go to the documentation of this file.

// Index class implementation -*- C++ -*-

// $Id: vdbl_index.h 921 2009-11-12 17:03:02Z mihaly $
// Copyright (C) 2003 Hermann Schichl
//
// This file is part of the Vienna Database Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef __VDBL_INDEX_H
#define __VDBL_INDEX_H

#include <list>
#include <typeinfo>
#include <counted_ptr.h>
#include <vdbl_config.h>
#include <vdbl_types.h>
#include <vdbl_col.h>

__VDBL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1209
#endif

typedef enum { vdbl_list_index, vdbl_map_index, vdbl_lexi_index, vdbl_index_error } VDBL_index_type;

class __VDBL_index
{
public:
  __VDBL_index() {}
  virtual ~__VDBL_index() {}

  virtual VDBL_index_type type() const VDBL_PURE_VIRTUAL

  virtual void destroy() VDBL_PURE_VIRTUAL
  virtual bool clear() VDBL_PURE_VIRTUAL
  virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
     VDBL_PURE_VIRTUAL
  virtual bool del(const _VDBL_rowid rid) VDBL_PURE_VIRTUAL

  virtual bool maximal(_VDBL_rowid& r) const VDBL_PURE_VIRTUAL
  virtual bool minimal(_VDBL_rowid& r) const VDBL_PURE_VIRTUAL

  virtual bool maximal(std::list<_VDBL_rowid>& _Ct) const VDBL_PURE_VIRTUAL
  virtual bool minimal(std::list<_VDBL_rowid>& _Ct) const VDBL_PURE_VIRTUAL

  virtual bool getval(const void* c, const std::type_info&, _VDBL_rowid& r) const
     VDBL_PURE_VIRTUAL
  virtual bool getval(const void* c, const std::type_info&, std::list<_VDBL_rowid>& _Ct) const
     VDBL_PURE_VIRTUAL
};

class index
{
private:
  counted_ptr<__VDBL_index> _i;

public:
  index(__VDBL_index* __i = NULL) : _i(__i) {}
  ~index() { if(_i.get()) { _i->destroy(); } }

  VDBL_index_type type() const { return _i.get() ? _i->type() : vdbl_index_error; }

  bool clear() { return _i.get() && _i->clear(); }
  bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
    { return _i.get() && _i->ins(_r, rid); }
  bool del(const _VDBL_rowid rid)
    { return _i.get() && _i->del(rid); }

  bool maximal(_VDBL_rowid& r) const { return _i.get() ? _i->maximal(r) : false; }
  bool minimal(_VDBL_rowid& r) const { return _i.get() ? _i->minimal(r) : false ; }

  template <class _Al>
  bool maximal(std::list<_VDBL_rowid, _Al>& _Ct) const
    { if(_i.get()) return _i->maximal(_Ct); else return false;}
  template <class _Al>
  bool minimal(std::list<_VDBL_rowid, _Al>& _Ct) const
    { if(_i.get()) return _i->minimal(_Ct); else return false;}
  template < template <class _TT, class _TA> class _SqCtr, class _Al >
  bool maximal(_SqCtr<_VDBL_rowid, _Al>& _Ct) const
    { if(_i.get()) {
        std::list<_VDBL_rowid> _l;
        bool ret = _i->maximal(_l);
        for(std::list<_VDBL_rowid>::const_iterator x = _l.begin(); x != _l.end();
            ++x)
          _Ct.insert(_Ct.end(), *x);
        return ret;
      } else return false;}
  template < template <class _TT, class _TA> class _SqCtr, class _Al >
  bool minimal(_SqCtr<_VDBL_rowid, _Al>& _Ct) const
    { if(_i.get()) {
        std::list<_VDBL_rowid> _l;
        bool ret = _i->minimal(_l);
        for(std::list<_VDBL_rowid>::const_iterator x = _l.begin(); x != _l.end();
            ++x)
          _Ct.insert(_Ct.end(), *x);
        return ret;
      } else return false;}

  template < class _T >
  bool getval(const _T& c, _VDBL_rowid& r) const
    { if(_i.get()) return _i->getval((void*)&c, typeid(_T), r); else return -1; }
  template < class _T, template <class _TT, class _TA> class _SqCtr, class _Al >
  bool getval(const _T& c, std::list<_VDBL_rowid>& _Ct) const
    { if(_i.get()) return _i->getval((void*)&c, typeid(_T), _Ct); else return false; }
  template < class _T, template <class _TT, class _TA> class _SqCtr, class _Al >
  bool getval(const _T& c, _SqCtr<_VDBL_rowid, _Al>& _Ct) const
    { if(_i.get()) {
        std::list<_VDBL_rowid> _l;
        bool ret = _i->getval((void*)&c, typeid(_T), _l);
        for(std::list<_VDBL_rowid>::const_iterator x = _l.begin(); x != _l.end();
            ++x)
          _Ct.insert(_Ct.end(), *x);
        return ret;
      } else return false;}
};

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1209
#endif

__VDBL_END_NAMESPACE

#endif /* __VDBL_INDEX_H */

// Local Variables:
// mode:C++
// End:

---