vdbl_lexiindex.h

Go to the documentation of this file.

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

// $Id: vdbl_index.h 347 2008-02-06 15:20:01Z schilly $
// 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_LEXIINDEX_H
#define __VDBL_LEXIINDEX_H

#include <map>
#include <list>
#include <triple>
#include <vdbl_listindex.h>

__VDBL_BEGIN_NAMESPACE

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

template <class _TR, class _TS>
class _VDBL_index_lex2 : public _VDBL_index_l<std::pair<_TR, _TS> >
{
private:
  typedef typename std::pair<_TR,_TS> type_t;
  typedef std::list<std::pair<type_t, _VDBL_rowid> > idx_t;
  typedef std::map<_VDBL_rowid, typename idx_t::iterator> itt_t;
  typedef _VDBL_index_l<std::pair<_TR, _TS> > _Base;

  _VDBL_colid c2;

public:
  _VDBL_index_lex2(_VDBL_colid __c, _VDBL_colid __c2) : _Base(__c), c2(__c2) {}
  virtual ~_VDBL_index_lex2() {}

  virtual VDBL_index_type type() const { return vdbl_lexi_index; }

  virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
    {
      bool error;
      const _VDBL_col& _c(_r.get_col(this->c, error));
      if(error)
        return false;
      else
      {
        const _VDBL_col& _c2(_r.get_col(c2, error));
        if(error)
          return false;
        else
        {
          const _TR* T;
          const _TS* S;
          _c.get_ptr(T);
          _c2.get_ptr(S);
          type_t R(std::make_pair(*T, *S));
          return ins(&R, rid);
        }
      }
    }
};

template <class _TR, class _TS>
class lexi_pair_index : public _VDBL_index_lex2<_TR, _TS>
{
private:
  typedef _VDBL_index_lex2<_TR, _TS> _Base;
};

template <class _TR, class _TS>
class lexi_pair_index_def : public _VDBL_index_lex2<_TR, _TS>
{
private:
  typedef _VDBL_index_lex2<_TR, _TS> _Base;
  typedef typename std::pair<_TR, _TS> type_t;

  _TR default_value1;
  _TS default_value2;

public: 
  lexi_pair_index_def(_VDBL_colid __c, _VDBL_colid __c2, const _TR& __d,
                 const _TS& __d2)
        : _Base(__c, __c2), default_value1(__d), default_value2(__d2)
        {}
  virtual ~lexi_pair_index_def() {}

public:
  virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
    {
      bool error1;
      bool error2;
      const _VDBL_col& _c(_r.get_col(this->c, error1));
      const _VDBL_col& _c2(_r.get_col(this->c2, error2));
      type_t U(std::make_pair(default_value1,default_value2));

      if(!error1)
      {
        const _TR *T;
        _c.get_ptr(T);
        U.first = *T;
      }
      if(!error2)
      {
        const _TS *T;
        _c2.get_ptr(T);
        U.second = *T;
      }
      return ins(&U, rid);
    }
};

template <class _TR, class _TS, class _TT>
class _VDBL_index_lex3 : public _VDBL_index_l<std::triple<_TR, _TS, _TT> >
{
private:
  typedef typename std::triple<_TR,_TS,_TT> type_t;
  typedef std::list<std::pair<type_t, _VDBL_rowid> > idx_t;
  typedef std::map<_VDBL_rowid, typename idx_t::iterator> itt_t;
  typedef _VDBL_index_l<std::pair<_TR, _TS> > _Base;

  _VDBL_colid c2;
  _VDBL_colid c3;

public:
  _VDBL_index_lex3(_VDBL_colid __c, _VDBL_colid __c2, _VDBL_colid __c3)
        : _Base(__c), c2(__c2), c3(__c3) {}
  virtual ~_VDBL_index_lex3() {}

  virtual VDBL_index_type type() const { return vdbl_lexi_index; }

  virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
    {
      bool error;
      const _VDBL_col& _c(_r.get_col(this->c, error));
      if(error)
        return false;
      else
      {
        const _VDBL_col& _c2(_r.get_col(c2, error));
        if(error)
          return false;
        else
        {
          const _VDBL_col& _c3(_r.get_col(c3, error));
          if(error)
            return false;
          else
          {
            const _TR* T;
            const _TS* S;
            const _TT* R;
            _c.get_ptr(T);
            _c2.get_ptr(S);
            _c3.get_ptr(R);
            type_t U(std::make_triple(*T, *S, *R));
            return ins(&U, rid);
          }
        }
      }
    }
};

template <class _TR, class _TS, class _TT>
class lexi_triple_index : public _VDBL_index_lex3<_TR, _TS, _TT>
{
private:
  typedef _VDBL_index_lex3<_TR, _TS, _TT> _Base;
};

template <class _TR, class _TS, class _TT>
class lexi_triple_index_def : public _VDBL_index_lex3<_TR, _TS, _TT>
{
private:
  typedef _VDBL_index_lex3<_TR, _TS, _TT> _Base;
  typedef typename std::pair<_TR, _TS> type_t;

  _TR default_value1;
  _TS default_value2;
  _TT default_value3;

public: 
  lexi_triple_index_def(_VDBL_colid __c, _VDBL_colid __c2, const _TR& __d,
                 const _TS& __d2, const _TT& __d3)
        : _Base(__c, __c2), default_value1(__d), default_value2(__d2),
          default_value3(__d3)
        {}
  virtual ~lexi_triple_index_def() {}

public:
  virtual bool ins(const _VDBL_row& _r, const _VDBL_rowid rid)
    {
      bool error1;
      bool error2;
      bool error3;
      const _VDBL_col& _c(_r.get_col(this->c, error1));
      const _VDBL_col& _c2(_r.get_col(this->c2, error2));
      const _VDBL_col& _c3(_r.get_col(this->c3, error3));
      type_t U(std::make_triple(default_value1,default_value2,default_value3));

      if(!error1)
      {
        const _TR *T;
        _c.get_ptr(T);
        U.first = *T;
      }
      if(!error2)
      {
        const _TS *T;
        _c2.get_ptr(T);
        U.second = *T;
      }
      if(!error3)
      {
        const _TT *T;
        _c3.get_ptr(T);
        U.third = *T;
      }
      return ins(&U, rid);
    }
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_LEXIINDEX_H */

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

---