vdbl_viewdbase.h

Go to the documentation of this file.

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

// $Id: vdbl_viewdbase.h 699 2008-09-01 13:59:33Z 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_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;

  const _VDBL_database* _D_db;
  _D_view_names _D_vn;
  _D_views _D_v;
  _VDBL_userid _D_uid;
  const _VDBL_context* _D_ctx;
  _V_enum _D_viewtype;
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())
    {
      if(_D_viewtype == V_window)
        return _D_db->get_tableid(_C_i, _D_uid);
      else
        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())
    {
      if(_D_viewtype == V_window)
        return _D_db->has_table(_C_i, _D_uid);
      else
        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())
    {
      if(_D_viewtype == V_window)
      {
        _VDBL_viewdbase* tthis = const_cast<_VDBL_viewdbase*>(this);
        // check whether the database contains the table
        if(_D_db->has_table(_C_i, _D_uid))
        {
          // make a new view
          _VDBL_view* __v(_D_db->get_table_view(_C_i, *_D_ctx, _D_viewtype));
          tthis->_D_v.insert(std::make_pair(_C_i, __v));
          tthis->_D_vn = _D_db->_D_tn;
          return __v;
        }
        else
          return NULL;
      }
      else
        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_db(NULL), _D_vn(), _D_v(), _D_uid(), _D_ctx(NULL),
                      _D_viewtype(V_frozen) {}

  _VDBL_viewdbase(const _VDBL_database& _db, const _VDBL_userid& uid,
                  const _VDBL_context& __c, const _V_enum& __e = V_frozen)
                        : _D_db(&_db), _D_vn(_db._D_tn), _D_v(),
                          _D_uid(uid), _D_ctx(&__c), _D_viewtype(__e)
  {
    if(_D_viewtype != V_window)
    {
      // 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, _D_viewtype)));
      }
    }
  }

  template <template <class _TC, class _TA> 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,
                  const _V_enum& __e = V_frozen)
                        : _D_db(&_db), _D_vn(_db._D_tn), _D_v(),
                          _D_uid(uid), _D_ctx(&__c), _D_viewtype(__e)
  {
    // 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, _D_viewtype, __an)));
    }
  }

  virtual ~_VDBL_viewdbase()
  {
    for(_D_views::iterator __x = _D_v.begin(); __x != _D_v.end(); ++__x)
      delete (*__x).second;
  }
  
  bool add_table_view(const _VDBL_tableid& __t, const std::string& __s,
                      const _VDBL_context& __c)
  {
    if(!_D_db) return false;
    // should check user here
    if(has_view(__t)) return true;
    _D_v.insert(std::make_pair(__t,
        _D_db->get_table_view(__t, __c, _D_viewtype)));
    _D_vn.insert(std::make_pair(__s, __t));
    return true;
  }
  
  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool add_table_view(const _VDBL_tableid& __t, const std::string& __s,
                      const _VDBL_context& __c,
                  const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    if(!_D_db) return false;
    // should check user here
    if(has_view(__t)) return true;
    _D_v.insert(std::make_pair(__t,
        _D_db->get_table_view(__t, __c, _D_viewtype, __an)));
    _D_vn.insert(std::make_pair(__s, __t));
    return true;
  }
  
  bool add_table_view(const std::string& __s, const _VDBL_context& __c)
  {
    if(!_D_db) return false;
    // should check user here
    _VDBL_tableid __t(_D_db->get_tableid(__s, _D_uid));
    return add_table_view(__t, __s, __c);
  }
  
  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool add_table_view(const std::string& __s, const _VDBL_context& __c,
                  const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    if(!_D_db) return false;
    // should check user here
    _VDBL_tableid __t(_D_db->get_tableid(__s, _D_uid));
    return add_table_view(__t, __s, __c, __an);
  }
  
  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool add_visible(const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    if(!_D_db) return false;
    // should check user here
    for(_D_views::iterator __x = _D_v.begin(); __x != _D_v.end(); ++__x)
      _D_db->add_to_table_view((*__x).second, (*__x).first, __an);
    return true;
  }

  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool rm_visible(const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    if(!_D_db) return false;
    // should check user here
    for(_D_views::iterator __x = _D_v.begin(); __x != _D_v.end(); ++__x)
      _D_db->rm_from_table_view((*__x).second, (*__x).first, __an);
    return true;
  }
};


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,
            view_enum e = V_frozen)
        : _Base(db,uid,c,e) {}

  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  viewdbase(const database& db, const userid& uid, const context& c,
            const _SqCtr<std::pair<tableid,rowid>,_Al>& __an,
            view_enum e = V_frozen)
                        : _Base(db,uid,c,__an,e) {}

  virtual ~viewdbase() {}
  
  bool add_table_view(const _VDBL_tableid& __t, const std::string& __s, 
                      const _VDBL_context& __c)
  {
    return _Base::add_table_view(__t, __s, __c);
  }
  
  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool add_table_view(const _VDBL_tableid& __t, const std::string& __s,
                  const _VDBL_context& __c,
                  const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    return _Base::add_table_view(__t, __s, __c, __an);
  }
  
  bool add_table_view(const std::string& __s, const _VDBL_context& __c)
  {
    return _Base::add_table_view(__s, __c);
  }
  
  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool add_table_view(const std::string& __s, const _VDBL_context& __c,
                  const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    return _Base::add_table_view(__s, __c, __an);
  }
  
  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool add_visible(const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    return _Base::add_visible(__an);
  }

  template <template <class _TC, class _TA> class _SqCtr, class _Al>
  bool rm_visible(const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>,_Al>& __an)
  {
    return _Base::rm_visible(__an);
  }
};

#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:

---