vdbl_database.h

Go to the documentation of this file.

// Database class implementation -*- C++ -*-

// $Id: vdbl_database.h 634 2008-05-20 14:28:14Z herman $
// 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_DATABASE_H
#define __VDBL_DATABASE_H

#define HAVE_VTABLE 0

#include <algorithm>
#include <map>
#include <vdbl_config.h>
#include <vdbl_types.h>
#include <vdbl_table.h>
#include <vdbl_user.h>
#include <vdbl_view.h>
#include <vdbl_stview.h>
#if HAVE_VTABLE
#include <vdbl_vtable.h>
#endif

__VDBL_BEGIN_NAMESPACE

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


class _VDBL_userflags
{
public:
  struct
  {
    bool all_tables_write;
    bool all_tables_read;
    bool all_tables_modify;
    bool all_tables_append;
    bool all_tables_delete;
  } table_privileges;

  struct
  {
    bool all_views_commit_to_parent;
  } view_privileges;

public:
  _VDBL_userflags() : table_privileges(), view_privileges() {}
  _VDBL_userflags(const _VDBL_userflags& _a)
        : table_privileges(_a.table_privileges),
          view_privileges(_a.view_privileges) {}
  virtual ~_VDBL_userflags() {}
};


class _VDBL_aclentry
{
public:

  bool read;
  bool write;
  bool append;
  bool drop;
  bool commit_to_parent;

public:
  _VDBL_aclentry(bool _r = false, bool _a = false, bool _w = false,
                 bool _d = false, bool _ctp = false)
                        : read(_r), write(_w), append(_a), drop(false),
                          commit_to_parent(_ctp)
      {}

  _VDBL_aclentry(const _VDBL_aclentry& _a) : read(_a.read),
                        write(_a.write), append(_a.append), drop(_a.drop),
                        commit_to_parent(_a.commit_to_parent)
      {}

  virtual ~_VDBL_aclentry() {}                     

  _VDBL_aclentry& operator=(const _VDBL_aclentry& __a)
  {
    read = __a.read;
    write = __a.write;
    append = __a.append;
    drop = __a.drop;
    commit_to_parent = __a.commit_to_parent;
    return *this;
  }
};


class _VDBL_acl
{
public:
  _VDBL_aclentry global;
  std::map<_VDBL_colid,_VDBL_aclentry> colwise;

public:
  _VDBL_acl(bool _gr = false, bool _ga = false, bool _gw = false,
            bool _gd = false, bool _gctp = false)
          : global(_gr,_ga,_gw,_gd,_gctp), colwise() {}

  _VDBL_acl(const _VDBL_acl& _a) : global(_a.global), colwise(_a.colwise) {}
        

  virtual ~_VDBL_acl() {}

  _VDBL_acl& operator=(const _VDBL_acl& __a)
  {
    global = __a.global;
    colwise = __a.colwise;
    return *this;
  }
};


class _VDBL_tableflags
{
public:
  //_VDBL_userid owner;
  bool temporary;
  bool unrestricted;
  _VDBL_acl global;
  std::map<_VDBL_userid,_VDBL_acl> ACLs;

public:
  _VDBL_tableflags(bool _temp = false, bool _unrest = true) :
               temporary(_temp), unrestricted(_unrest), global(), ACLs() 
     {}

  _VDBL_tableflags(const _VDBL_acl& _gacl, bool _temp = false,
                   bool _unrest = true) : temporary(_temp),
                                unrestricted(_unrest), global(_gacl), ACLs() 
     {}

  _VDBL_tableflags(const _VDBL_tableflags& __t) :
                temporary(__t.temporary), unrestricted(__t.unrestricted),
                global(__t.global), ACLs(__t.ACLs)
     {}

  virtual ~_VDBL_tableflags() {}

  _VDBL_tableflags& operator=(const _VDBL_tableflags& __t)
  {
    temporary = __t.temporary;
    unrestricted = __t.unrestricted;
    global = __t.global;
    ACLs = __t.ACLs;
    return *this;
  }
};


class _VDBL_viewflags
{
public:
  _VDBL_acl global;
  std::map<_VDBL_userid,_VDBL_acl> ACLs;

public:
  _VDBL_viewflags() : global(), ACLs() {}
  
  _VDBL_viewflags(const _VDBL_acl& _gacl) : global(_gacl), ACLs() {}

  _VDBL_viewflags(const _VDBL_viewflags& __v) :
                        global(__v.global), ACLs(__v.ACLs) {}
  virtual ~_VDBL_viewflags() {}

  _VDBL_viewflags& operator=(const _VDBL_viewflags& __v)
  {
    global = __v.global;
    ACLs = __v.ACLs;
    return *this;
  }
};


class _VDBL_database
{
private:
  typedef std::pair<_VDBL_tableflags,_VDBL_table*> _D_table_entry;
  typedef std::map<std::string, _VDBL_tableid> _D_table_names;
  typedef std::map<_VDBL_tableid, _D_table_entry> _D_tables;

  typedef std::triple<_VDBL_userid,_VDBL_userflags,_VDBL_user> _D_user_entry;
  typedef std::map<std::string, _D_user_entry> _D_users;

  typedef std::pair<_VDBL_viewflags,_VDBL_view*> _D_view_entry;
  typedef std::map<std::string, _VDBL_viewid> _D_view_names;
  typedef std::map<_VDBL_viewid, _D_view_entry> _D_views;


  _VDBL_tableid _D_ti;
  _VDBL_userid _D_ui;
  _VDBL_viewid _D_vi;

  _D_table_names _D_tn;
  _D_tables _D_t;
  _D_users _D_u;
  _D_view_names _D_vn;
  _D_views _D_v;
 
protected:

  _VDBL_tableid get_tableid() { return ++_D_ti; }
  _VDBL_userid get_userid() { return ++_D_ui; }
  _VDBL_viewid get_viewid() { return ++_D_vi; }
 
public:

  bool create_table(const std::string& _C_i, const _VDBL_userid& _C_u,
                    const _VDBL_tableflags& __f = _VDBL_tableflags())
  {
    // should check user first - for now ignored
    _D_table_names::iterator __t(_D_tn.find(_C_i));
    if(__t != _D_tn.end())
      return false;
    _VDBL_table* _ntb = (_VDBL_table*) new _VDBL_standardtable;
    _VDBL_tableid _ti(get_tableid());
    _D_tn.insert(std::make_pair(_C_i,_ti));
    _D_t.insert(std::make_pair(_ti,std::make_pair(__f,_ntb)));
    return true;
  }

#if HAVE_VTABLE

  bool create_table(const std::string& _C_i, const _VDBL_userid& _C_u,
                    const _VDBL_tableflags& __f = _VDBL_tableflags(),
                    const _VDBL_view& __v)
  {
    // should check user first - for now ignored
    _D_table_names::iterator __t(_D_tn.find(_C_i));
    if(__t != _D_tn.end())
      return false;
    _VDBL_table* _ntb = (_VDBL_table*) new _VDBL_viewtable(__v);
    _VDBL_tableid _ti(get_tableid());
    _D_tn.insert(std::make_pair(_C_i,_ti));
    _D_t.insert(std::make_pair(_ti,std::make_pair(__f,_ntb)));
    return true;
  }
#endif

  _VDBL_tableid get_tableid(const std::string& _C_i,
                            const _VDBL_userid& _C_u) const
  {
    // should check user first
    _D_table_names::const_iterator __t(_D_tn.find(_C_i));
    if(__t == _D_tn.end())
      return _VDBL_tableid();
    else
      return (*__t).second;
  }

  bool alter_table(const _VDBL_tableid& _ti, const _VDBL_userid& _C_u)
  { throw "alter_table: NYI"; }

  bool alter_table(const std::string& _C_i, const _VDBL_userid& _C_u)
  { return alter_table(get_tableid(_C_i, _C_u), _C_u); }

  bool drop_table(const _D_tables::iterator& __t,
                  const _D_table_names::iterator& __tn,
                  const _VDBL_userid& _C_u)
  {
    bool ret(true);
    // should check user first - for now ignored
    if(__t != _D_t.end())
    {
      _VDBL_table* _otb = (*__t).second.second;
      delete _otb;
      _D_t.erase(__t);
    }
    else
      ret = false;
    if(__tn != _D_tn.end())
      _D_tn.erase(__tn);
    else
      ret = false;
    return ret;
  }

  bool drop_table(const _VDBL_tableid& _C_i, const _VDBL_userid& _C_u)
  {
    _D_table_names::iterator __t;
    for(__t = _D_tn.begin(); __t != _D_tn.end(); ++__t)
      if((*__t).second == _C_i)
        break;
    return drop_table(_D_t.find(_C_i), __t, _C_u);
  }

  bool drop_table(const std::string& _C_i, const _VDBL_userid& _C_u)
  { 
    _VDBL_tableid _ti(get_tableid(_C_i, _C_u));
    return drop_table(_D_t.find(_ti), _D_tn.find(_C_i), _C_u);
  }

  bool has_table(const _VDBL_tableid& _C_i, const _VDBL_userid& _C_u) const
  {
    _D_tables::const_iterator __t(_D_t.find(_C_i));
    if(__t == _D_t.end())
      return false;
    else
      return true;
  }

  bool has_table(const std::string& _C_i, const _VDBL_userid& _C_u) const
  { return has_table(get_tableid(_C_i, _C_u), _C_u); }

public:
  _VDBL_table* get_table(const _VDBL_tableid& _C_i, const _VDBL_userid& _C_u)
     const
  {
    // should check user here
    _D_tables::const_iterator __t(_D_t.find(_C_i));
    if(__t == _D_t.end())
      return NULL;
    return (*__t).second.second;
  }

  _VDBL_table* get_table(const std::string& _C_i, const _VDBL_userid& _C_u) const
  { return get_table(get_tableid(_C_i, _C_u), _C_u); }

private:
  _VDBL_view* get_table_view(const _VDBL_tableid& _C_i,
                        const _VDBL_context& __c, const _V_enum& __e) const
  {
    _D_tables::const_iterator __t(_D_t.find(_C_i));
    if(__t == _D_t.end())
      return NULL;
    _VDBL_view* __v = new
                _VDBL_standardview(_C_i, (*__t).second.second, __c, __e);
    return __v;
  }

  _VDBL_view* get_table_view(const std::string& _C_i, const _VDBL_context& __c,
                             const _V_enum& __e) const
  {
    _D_table_names::const_iterator _ti(_D_tn.find(_C_i));
    if(_ti == _D_tn.end())
      return NULL;
    return get_table_view((*_ti).second, __c, __e);
  }

  template < template <class _TT, class _TA> class _SqCtr, class _Al >
  _VDBL_view* get_table_view(const _VDBL_tableid& _C_i,
      const _VDBL_context& __c, const _V_enum& __e,
      const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>& _Ct) const
  {
    _D_tables::const_iterator __t(_D_t.find(_C_i));
    if(__t == _D_t.end())
      return NULL;
    std::vector<_VDBL_rowid> _r;
    typename _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>::const_iterator _a;
    _r.reserve(_Ct.size());
    for(_a = _Ct.begin(); _a != _Ct.end(); ++_a)
      if(_C_i == (*_a).first)
        _r.push_back((*_a).second);
    _VDBL_view* __v = new _VDBL_standardview(_C_i, (*__t).second.second,
                                             __c, __e, _r);
    return __v;
  }

  template < template <class _TT, class _TA> class _SqCtr, class _Al >
  _VDBL_view* get_table_view(const std::string& _C_i, const _VDBL_context& __c,
      const _V_enum& __e,
      const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>& _Ct) const
  {
    _D_table_names::const_iterator _ti(_D_tn.find(_C_i));
    if(_ti == _D_tn.end())
      return NULL;
    return get_table_view((*_ti).second, __c, __e, _Ct);
  }

  template < template <class _TT, class _TA> class _SqCtr, class _Al >
  bool add_to_table_view(_VDBL_view* __v, const _VDBL_tableid& _C_i,
      const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>& _Ct) const
  {
    std::vector<_VDBL_rowid> _r;
    typename _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>::const_iterator _a;
    _r.reserve(_Ct.size());
    for(_a = _Ct.begin(); _a != _Ct.end(); ++_a)
      if(_C_i == (*_a).first)
        _r.push_back((*_a).second);
    return __v->add_visible(_r);
  }

  template < template <class _TT, class _TA> class _SqCtr, class _Al >
  bool rm_from_table_view(_VDBL_view* __v, const _VDBL_tableid& _C_i,
      const _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>& _Ct) const
  {
    std::vector<_VDBL_rowid> _r;
    typename _SqCtr<std::pair<_VDBL_tableid,_VDBL_rowid>, _Al>::const_iterator _a;
    _r.reserve(_Ct.size());
    for(_a = _Ct.begin(); _a != _Ct.end(); ++_a)
      if(_C_i == (*_a).first)
        _r.push_back((*_a).second);
    return __v->rm_visible(_r);
  }

public:

  _VDBL_viewid get_viewid(const std::string& _C_i, const _VDBL_userid& _C_u) const
  {
    _D_view_names::const_iterator __v(_D_vn.find(_C_i));
    if(__v == _D_vn.end())
      return _VDBL_viewid();
    else
      return (*__v).second;
  }
  
  bool create_view(const std::string& _C_i, const _VDBL_userid& _C_u,
                   const _VDBL_context& __c,
                   const std::string& _C_t, const _V_enum& __e)
  {
    // should check user here!
    _D_view_names::iterator __v(_D_vn.find(_C_i));
    if(__v != _D_vn.end())
      return false;
    _VDBL_view* __vi = get_table_view(_C_t, __c, __e);
    if(__vi == NULL)
      return false;
    _VDBL_viewid _vid(get_viewid());
    _D_vn.insert(std::make_pair(_C_i,_vid));
    _D_v.insert(std::make_pair(_vid, std::make_pair(_VDBL_viewflags(),__vi)));
    return true;
  }

  bool alter_view(const _VDBL_viewid& _C_i, const _VDBL_userid& _C_u)
        { throw "alter_view: NYI"; }

  bool alter_view(const std::string& _C_i, const _VDBL_userid& _C_u)
  { return alter_view(get_viewid(_C_i, _C_u), _C_u); }

  bool drop_view(const _D_views::iterator& __v,
                 const _D_view_names::iterator& __vn,
                 const _VDBL_userid& _C_u)
  {
    bool ret(true);
    // should check user first - for now ignored
    if(__v != _D_v.end())
    {
      _VDBL_view* _ovw = (*__v).second.second;
      delete _ovw;
      _D_v.erase(__v);
    }
    else
      ret = false;
    if(__vn != _D_vn.end())
      _D_vn.erase(__vn);
    else
      ret = false;
    return ret;
  }

  bool drop_view(const _VDBL_viewid& _C_i, const _VDBL_userid& _C_u)
  {
    _D_view_names::iterator __v;
    for(__v = _D_vn.begin(); __v != _D_vn.end(); ++__v)
      if((*__v).second == _C_i)
        break;
    return drop_view(_D_v.find(_C_i), __v, _C_u);
  }

  bool drop_view(const std::string& _C_i, const _VDBL_userid& _C_u)
  { 
    _VDBL_viewid _vi(get_viewid(_C_i, _C_u));
    return drop_view(_D_v.find(_vi), _D_vn.find(_C_i), _C_u);
  }

  bool has_view(const _VDBL_viewid& _C_i, const _VDBL_userid& _C_u) 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 _VDBL_userid& _C_u) const
  { return has_view(get_viewid(_C_i, _C_u), _C_u); }

  _VDBL_view* get_view(const _VDBL_viewid& _C_i, const _VDBL_userid& _C_u) 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.second;
  }

  _VDBL_view* get_view(const std::string& _C_i, const _VDBL_userid& _C_u) const
  { return get_view(get_viewid(_C_i,_C_u), _C_u); }

  bool create_user(const std::string& _C_i) { throw "create_user: NYI"; }
  bool alter_user(const std::string& _C_i) { throw "alter_user: NYI"; }
  bool drop_user(const std::string& _C_i) { throw "drop_user: NYI"; }
  const _VDBL_userid& get_user(const std::string& _C_i) const
        { throw "get_user: NYI"; }
  bool has_user(const std::string& _C_i) const { throw "has_user: NYI"; }

  _VDBL_database() : _D_ti(), _D_ui(), _D_vi(), _D_tn(),
                     _D_t(), _D_u(), _D_vn(), _D_v() {}

  _VDBL_database(const _VDBL_database& __t)
                : _D_ti(__t._D_ti), _D_ui(__t._D_ui), _D_vi(__t._D_vi),
                  _D_tn(__t._D_tn), _D_t(__t._D_t), _D_u(__t._D_u),
                  _D_vn(__t._D_vn), _D_v(__t._D_v)
  {
    for(_D_tables::iterator __x = _D_t.begin(); __x != _D_t.end(); ++__x)
      (*__x).second.second = (*__x).second.second->new_copy();
    for(_D_views::iterator __x = _D_v.begin(); __x != _D_v.end(); ++__x)
      (*__x).second.second = (*__x).second.second->new_copy();
  }

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

  friend class _VDBL_viewdbase;
};


class database : public _VDBL_database
{
private:
  typedef _VDBL_database _Base;

public:
  typedef _VDBL_table table;
  typedef _VDBL_view view;
  typedef _VDBL_user user;

public:
  bool create_table(const std::string& _C_i, const _VDBL_userid& _C_u,
                    const _VDBL_tableflags& __f = _VDBL_tableflags())
        { return _Base::create_table(_C_i, _C_u, __f); }
  bool create_table(const char* _C_i, const _VDBL_userid& _C_u,
                    const _VDBL_tableflags& __f = _VDBL_tableflags())
        { return create_table(std::string(_C_i), _C_u, __f); }
#if HAVE_VTABLE

  bool create_table(const char* _C_i, const _VDBL_userid& _C_u,
                    const _VDBL_tableflags& __f = _VDBL_tableflags(),
                    const _VDBL_view& __v)
        { return _Base::create_table(std::string(_C_i), _C_u, __f, __v); }
#endif
  bool alter_table(const std::string& _C_i, const _VDBL_userid& _C_u)
        { return _Base::alter_table(_C_i, _C_u); }
  bool alter_table(const char* _C_i, const _VDBL_userid& _C_u)
        { return _Base::alter_table(std::string(_C_i), _C_u); }
  bool drop_table(const std::string& _C_i, const _VDBL_userid& _C_u)
        { return _Base::drop_table(_C_i, _C_u); }
  bool drop_table(const char* _C_i, const _VDBL_userid& _C_u)
        { return _Base::drop_table(std::string(_C_i), _C_u); }
  bool has_table(const std::string& _C_i, const _VDBL_userid& _C_u) const
        { return _Base::has_table(_C_i, _C_u); }
  bool has_table(const char* _C_i, const _VDBL_userid& _C_u) const
        { return _Base::has_table(std::string(_C_i), _C_u); }
  bool create_view(const std::string& _C_i, const _VDBL_userid& _C_u,
                   const _VDBL_context& __c,
                   const std::string& _C_t, const _V_enum& __e)
        { return _Base::create_view(_C_i, _C_u, __c, _C_t, __e); }
  bool create_view(const char* _C_i, const _VDBL_userid& _C_u,
                   const _VDBL_context& __c,
                   const std::string& _C_t, const _V_enum& __e)
        { return _Base::create_view(std::string(_C_i), _C_u, __c, _C_t, __e); }
  bool create_view(const std::string& _C_i, const _VDBL_userid& _C_u,
                   const _VDBL_context& __c,
                   const char* _C_t, const _V_enum& __e)
        { return _Base::create_view(_C_i, _C_u, __c, std::string(_C_t), __e); }
  bool create_view(const char* _C_i, const _VDBL_userid& _C_u,
                   const _VDBL_context& __c,
                   const char* _C_t, const _V_enum& __e)
        { return _Base::create_view(std::string(_C_i), _C_u, __c,
                             std::string(_C_t), __e); }
  bool alter_view(const std::string& _C_i, const _VDBL_userid& _C_u)
        { return _Base::alter_view(_C_i, _C_u); }
  bool alter_view(const char* _C_i, const _VDBL_userid& _C_u)
        { return _Base::alter_view(std::string(_C_i), _C_u); }
  bool drop_view(const std::string& _C_i, const _VDBL_userid& _C_u)
        { return _Base::drop_view(_C_i, _C_u); }
  bool drop_view(const char* _C_i, const _VDBL_userid& _C_u)
        { return _Base::drop_view(std::string(_C_i), _C_u); }
  bool has_view(const std::string& _C_i, const _VDBL_userid& _C_u) const
        { return _Base::has_view(_C_i, _C_u); }
  bool has_view(const char* _C_i, const _VDBL_userid& _C_u) const
        { return _Base::has_view(std::string(_C_i), _C_u); }
  viewbase* get_view(const std::string& _C_i, const _VDBL_userid& _C_u) const
        { return (viewbase*)_Base::get_view(_C_i, _C_u); }
  viewbase* get_view(const char* _C_i, const _VDBL_userid& _C_u) const
        { return (viewbase*)_Base::get_view(std::string(_C_i), _C_u); }
  bool create_user(const char* _C_i)
        { return _Base::create_user(std::string(_C_i)); }
  bool create_user(const std::string& _C_i)
        { return _Base::create_user(_C_i); }
  bool alter_user(const char* _C_i)
        { return _Base::alter_user(std::string(_C_i)); }
  bool alter_user(const std::string& _C_i)
        { return _Base::alter_user(_C_i); }
  bool drop_user(const char* _C_i)
        { return _Base::drop_user(std::string(_C_i)); }
  bool drop_user(const std::string& _C_i)
        { return _Base::drop_user(_C_i); }
  const _VDBL_userid& get_user(const char* _C_i) const
        { return _Base::get_user(std::string(_C_i)); }
  const _VDBL_userid& get_user(const std::string& _C_i) const
        { return _Base::get_user(_C_i); }
  bool has_user(const char* _C_i) const
        { return _Base::has_user(std::string(_C_i)); }
  bool has_user(const std::string& _C_i) const
        { return _Base::has_user(_C_i); }
  table* get_table(const tableid& _C_i, const _VDBL_userid& _C_u) const
        { return (table*)_Base::get_table(_C_i,_C_u); }
  table* get_table(const std::string& _C_i, const _VDBL_userid& _C_u) const
        { return (table*)_Base::get_table(_C_i,_C_u); }
  table* get_table(const char* _C_i, const _VDBL_userid& _C_u) const
        { return get_table(std::string(_C_i),_C_u); }
};


typedef _VDBL_userflags userflags;

typedef _VDBL_viewflags viewflags;

typedef _VDBL_tableflags tableflags;


typedef _VDBL_aclentry aclentry;

typedef _VDBL_acl acl;

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_DATABASE_H */

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

---