---

vdbl_viewdbase.h

Go to the documentation of this file.

// View database class implementation -*- C++ -*-

// 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_VIEWDBASE_H
#define __VDBL_VIEWDBASE_H

#include <algorithm>
#include <map>
#include <vdbl_config.h>
#include <vdbl_database.h>

__VDBL_BEGIN_NAMESPACE

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


class _VDBL_viewdbase
{
private:
  typedef std::map<std::string, _VDBL_tableid> _D_view_names;
  typedef std::map<_VDBL_tableid, _VDBL_view*> _D_views;

  _D_view_names _D_vn;
  _D_views _D_v;
  
public:
  _VDBL_tableid get_tableid(const std::string& _C_i) const
  {
    // should check user first
    _D_view_names::const_iterator __t(_D_vn.find(_C_i));
    if(__t == _D_vn.end())
      return _VDBL_tableid();
    else
      return (*__t).second;
  }

public:
  bool has_view(const _VDBL_tableid& _C_i) const
  {
    _D_views::const_iterator __v(_D_v.find(_C_i));
    if(__v == _D_v.end())
      return false;
    else
      return true;
  }

  bool has_view(const std::string& _C_i) const
  { return has_view(get_tableid(_C_i)); }

  _VDBL_view* get_view(const _VDBL_tableid& _C_i) const
  {
    // should check the user here
    _D_views::const_iterator __v(_D_v.find(_C_i));
    if(__v == _D_v.end())
      return NULL;
    return (*__v).second;
  }

  _VDBL_view* get_view(const std::string& _C_i) const
  { return get_view(get_tableid(_C_i)); }

  _VDBL_viewdbase() : _D_vn(), _D_v() {}

  _VDBL_viewdbase(const _VDBL_database& _db, const _VDBL_userid& uid,
                  const _VDBL_context& __c)
                        : _D_vn(_db._D_tn), _D_v()
  {
    // should check user here
    for(_VDBL_database::_D_tables::const_iterator __x = _db._D_t.begin();
        __x != _db._D_t.end(); ++__x)
    {
      _D_v.insert(std::make_pair((*__x).first,
            _db.get_table_view((*__x).first, __c, V_frozen)));
    }
  }

  template <template <class _C, class _A> class _SqCtr, class _Al>
  _VDBL_viewdbase(const _VDBL_database& _db, const _VDBL_userid& uid,
                  const _VDBL_context& __c,
                  const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
                        : _D_vn(_db._D_tn), _D_v()
  {
    // should check user here
    for(_VDBL_database::_D_tables::const_iterator __x = _db._D_t.begin();
        __x != _db._D_t.end(); ++__x)
    {
      _D_v.insert(std::make_pair((*__x).first,
            _db.get_table_view((*__x).first, __c, V_frozen, __an)));
    }
  }

  virtual ~_VDBL_viewdbase()
  {
    for(_D_views::iterator __x = _D_v.begin(); __x != _D_v.end(); ++__x)
      delete (*__x).second;
  }
};


class viewdbase : public _VDBL_viewdbase
{
private:
  typedef _VDBL_viewdbase _Base;

public:
  typedef _VDBL_view view;

public:
  bool has_view(const char* _C_i) const
        { return _Base::has_view(std::string(_C_i)); }
  viewbase* get_view(const char* _C_i) const
        { return (viewbase*)_Base::get_view(std::string(_C_i)); }
  viewbase* get_view(const std::string& _C_i) const
        { return (viewbase*)_Base::get_view(_C_i); }

  viewdbase() : _Base() {}

  viewdbase(const database& db, const userid& uid, const context& c)
        : _Base(db,uid,c) {}

  template <template <class _C, class _A> class _SqCtr, class _Al>
  viewdbase(const database& db, const userid& uid, const context& c,
            const _SqCtr<std::pair<tableid,rowid>,_Al>& __an)
                        : _Base(db,uid,c,__an) {}

  virtual ~viewdbase() {}
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_VIEWDBASE_H */

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

---