vdbl_hrview.h

Go to the documentation of this file.

// Hierarchical view implementation -*- C++ -*-

// $Id: vdbl_hrview.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_HRVIEW_H
#define __VDBL_HRVIEW_H

#include <iostream>
#include <vdbl_table.h>
#include <vdbl_view.h>

__VDBL_BEGIN_NAMESPACE

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


class _VDBL_hierarchicalview : public _VDBL_view
{
private:
  typedef _VDBL_view _Base;
  
  typedef _VDBL_colid _V_colref;
  typedef std::pair<_VDBL_tableid,_VDBL_rowid> _V_rowref;
  typedef std::map<_V_rowref, _VDBL_col> _V_colentry;
  typedef std::map<_V_colref, _V_colentry> _V_colcache;
  typedef std::vector<_V_rowref> _V_rows;
  typedef std::vector<_V_colref> _V_cols;
  typedef std::map<std::pair<_VDBL_tableid,_VDBL_colid>,_VDBL_colid> _V_colxref;
  typedef std::map<_VDBL_tableid,std::pair<_VDBL_table *,unsigned int> > _V_tref;
  
private:
  std::vector<_VDBL_tableid> _V_th;
  _V_tref _V_t;
  const _VDBL_context* _V_ctx;

  _V_colcache _V_cc;

protected:
  _V_rows _V_r;
  _V_cols _V_c;
  _V_colxref _V_cx;

private:
  std::map<std::string,_V_colref> _V_colnames;

  friend class _VDBL_table;

public:
  typedef _Base::default_const_iterator defaults_const_iterator;

private:
  _VDBL_tableid get_master_table_id() const
  {
    std::vector<_VDBL_tableid>::const_iterator _e = _V_th.end();
    return *(--_e);
  }

  _VDBL_table* get_table(const _VDBL_tableid& _ti) const
  {
    _V_tref::const_iterator _tr(_V_t.find(_ti));
    if(_tr == _V_t.end())
      return NULL;
    return (*_tr).second.first;
  }

  _VDBL_table* get_master_table() const
  {
    std::vector<_VDBL_tableid>::const_iterator _e = _V_th.end();
    _V_tref::const_iterator _tr(_V_t.find(*(--_e)));
    if(_tr == _V_t.end())
    {
      std::cerr << "Error: hierarchical view is corrupted!" << std::endl;
      throw "Programming Error";
    }
    return (*_tr).second.first;
  }

  std::pair<_VDBL_tableid,_VDBL_colid> _find_def(const _VDBL_colid& _c) const
  {
    std::vector<_VDBL_tableid>::const_iterator _x, _e(_V_th.end());
    for(_x = _V_th.begin(); _x != _e; ++_x)
    {
      _V_colxref::const_iterator _cy(_V_cx.find(std::make_pair(*_x,_c)));
      if(_cy != _V_cx.end())
      {
        _VDBL_table* _tp = get_table(*_x);
        if(_tp && _tp->has_def((*_cy).second))
          return std::make_pair(*_x,(*_cy).second);
      }
    }
    return std::make_pair(0,0);
  }

  std::pair<_VDBL_tableid,_VDBL_colid> _find_col(const _VDBL_rowid& _r,
                                                 const _VDBL_colid& _c) const
  {
    std::vector<_VDBL_tableid>::const_iterator _x, _e(_V_th.end());
    for(_x = _V_th.begin(); _x != _e; ++_x)
    {
      _V_colxref::const_iterator _cy(_V_cx.find(std::make_pair(*_x,_c)));
      if(_cy != _V_cx.end())
      {
        _VDBL_table* _tp = get_table(*_x);
        if(_tp && _tp->has_col(_r,(*_cy).second))
          return std::make_pair(*_x,(*_cy).second);
      }
    }
    return _find_def(_c);
  }
  
protected:
  std::triple<_VDBL_tableid,_VDBL_colid,void*>
        _next_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
                      void *_d) const
    {
      _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
      std::pair<_VDBL_tableid,_VDBL_colid> _tc(0,0);
      if(_t == 0 && _c == 0) // end
        return std::make_triple(0,0,_d);
      ++_cit;
      while(_cit != _V_c.end())
      {
        _tc = _find_def(*_cit);
        if(_tc.first != 0)
          break;
        ++_cit;
      }
      if(_cit == _V_c.end())
        return std::make_triple(0,0,_d);
      else
        return std::make_triple(_tc.first,_tc.second,_d);
    }

  std::triple<_VDBL_tableid,_VDBL_colid,void*>
        _prev_def_col(const _VDBL_tableid& _t, const _VDBL_colid& _c,
                      void *_d) const
    {
      _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
      std::pair<_VDBL_tableid,_VDBL_colid> _tc(0,0);
      if(_t == 0 && _c == 0) // end
        _cit = _V_c.end();
      --_cit;
      while(_cit != _V_c.begin())
      {
        _tc = _find_def(*_cit);
        if(_tc.first != 0)
          break;
        --_cit;
      }
      if(_cit == _V_c.begin())
      {
        _tc = _find_def(*_cit);
        if(_tc.first == 0)
          return std::make_triple(0,0,_d);
      }
      if(_cit == _V_c.end())
        return std::make_triple(0,0,_d);
      else
        return std::make_triple(_tc.first,_tc.second,_d);
    }

  void _destroy_def_data(void *&_d) const
    { delete (_V_cols::const_iterator*)_d; }
  
  void* _copy_def_data(void *_d) const
    { return (void*)
        new _V_cols::const_iterator(*(_V_cols::const_iterator*)_d); }
  
  std::triple<_VDBL_tableid,_VDBL_colid,void*>
        _next_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
                  const _VDBL_colid& _c, void *_d) const
    {
      _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
      std::pair<_VDBL_tableid,_VDBL_colid> _tc(0,0);
      if(_t == 0 && _c == 0) // end
        return std::make_triple(0,0,_d);
      ++_cit;
      while(_cit != _V_c.end())
      {
        _tc = _find_col(_r,*_cit);
        if(_tc.first != 0)
          break;
        ++_cit;
      }
      if(_cit == _V_c.end())
        return std::make_triple(0,0,_d);
      else
        return std::make_triple(_tc.first,_tc.second,_d);
    }

  std::triple<_VDBL_tableid,_VDBL_colid,void*>
        _prev_col(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
                  const _VDBL_colid& _c, void *_d) const
    {
      _V_cols::const_iterator& _cit(*(_V_cols::const_iterator*)_d);
      std::pair<_VDBL_tableid,_VDBL_colid> _tc(0,0);
      if(_t == 0 && _c == 0) // end
        _cit = _V_c.end();
      --_cit;
      while(_cit != _V_c.begin())
      {
        _tc = _find_col(_r,*_cit);
        if(_tc.first != 0)
          break;
        --_cit;
      }
      if(_cit == _V_c.begin())
      {
        _tc = _find_def(*_cit);
        if(_tc.first == 0)
           return std::make_triple(0,0,_d);
      }
      if(_cit == _V_c.end())
        return std::make_triple(0,0,_d);
      else
        return std::make_triple(_tc.first,_tc.second,_d);
    }

  void _destroy_col_data(void *&_d) const
    { delete (_V_cols::const_iterator*)_d; }
  
  void* _copy_col_data(void *_d) const
    { return (void*)
        new _V_cols::const_iterator(*(_V_cols::const_iterator*)_d); }
  
  std::triple<_VDBL_tableid,_VDBL_rowid,void*>
        _next_row(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
                      void *_d) const
    {
      _V_rows::const_iterator& _rit(*(_V_rows::const_iterator*)_d);
      if(_t == 0 && _r == 0) // end
        return std::make_triple(0,0,_d);
      ++_rit;
      if(_rit == _V_r.end())
        return std::make_triple(0,0,_d);
      else
        return std::make_triple((*_rit).first,(*_rit).second,_d);
    }

  std::triple<_VDBL_tableid,_VDBL_rowid,void*>
        _prev_row(const _VDBL_tableid& _t, const _VDBL_rowid& _r,
                      void *_d) const
    {
      _V_rows::const_iterator& _rit(*(_V_rows::const_iterator*)_d);
      if(_t == 0 && _r == 0) // end
        _rit = _V_r.end();
      if(_rit == _V_r.begin())
        return std::make_triple(0,0,_d);
      --_rit;
      if(_rit == _V_r.end())
        return std::make_triple(0,0,_d);
      else
        return std::make_triple((*_rit).first,(*_rit).second,_d);
    }
  
  void _destroy_row_data(void *&_d) const
    { delete (_V_rows::const_iterator*)_d; }
  
  void* _copy_row_data(void *_d) const
    { return (void*)
        new _V_rows::const_iterator(*(_V_rows::const_iterator*)_d); }
  
private:
  bool _row_visible(const std::pair<_VDBL_tableid,_VDBL_rowid>& _r) const
  {
    return std::binary_search(_V_r.begin(), _V_r.end(), _r);
  }

public:
  _VDBL_hierarchicalview(const _VDBL_tableid& __ti, _VDBL_table* __t,
                     const _VDBL_context& __c, _V_enum __en)
              : _Base(__en), _V_th(1,__ti), _V_t(), _V_ctx(&__c),
                _V_cc(), _V_r(), _V_c(), _V_cx(), _V_colnames()
      {
        _V_t.insert(std::make_pair(__ti,
                                std::make_pair(__t,__t->get_change_ctr())));
        _VDBL_table::col_const_iterator __x, __e(__t->col_end());
        for(__x = __t->col_begin(); __x != __e; ++__x)
        {
          _V_colnames.insert(*__x);
          _V_c.push_back((*__x).second);
          _V_cx.insert(std::make_pair(std::make_pair(__ti,(*__x).second),
                                        (*__x).second));
        }
        _VDBL_table::row_const_iterator __y, __f(__t->row_end());
        for(__y = __t->row_begin(); __y != __f; ++__y)
          _V_r.push_back(std::make_pair(__ti,*__y));
        std::sort(_V_r.begin(), _V_r.end());
      }

  _VDBL_hierarchicalview(const _VDBL_tableid& __ti, _VDBL_table* __t,
                     const _VDBL_context& __c, _V_enum __en,
                     const std::vector<_VDBL_rowid>& _rs)
              : _Base(__en), _V_th(1,__ti), _V_t(), _V_ctx(&__c),
                _V_cc(), _V_r(), _V_c(), _V_cx(), _V_colnames()
      {
        _V_t.insert(std::make_pair(__ti,
                                std::make_pair(__t,__t->get_change_ctr())));
        _VDBL_table::col_const_iterator __x, __e(__t->col_end());
        for(__x = __t->col_begin(); __x != __e; ++__x)
        {
          _V_colnames.insert(*__x);
          _V_c.push_back((*__x).second);
          _V_cx.insert(std::make_pair(std::make_pair(__ti,(*__x).second),
                                                                (*__x).second));
        }
        std::vector<_VDBL_rowid>::const_iterator __y, __f(_rs.end());
        _V_r.reserve(_rs.size());
        for(__y = _rs.begin(); __y != __f; ++__y)
          _V_r.push_back(std::make_pair(__ti,*__y));
        std::sort(_V_r.begin(), _V_r.end());
      }

  _VDBL_hierarchicalview(const _VDBL_hierarchicalview& __v)
                : _Base(__v), _V_th(__v._V_th), _V_t(__v._V_t),
                  _V_ctx(__v._V_ctx), _V_cc(__v._V_cc), _V_r(__v._V_r),
                  _V_c(__v._V_c), _V_cx(__v._V_cx), _V_colnames(__v._V_colnames)
      {}

  virtual ~_VDBL_hierarchicalview() {}

  void push_table(const _VDBL_tableid& __ti, _VDBL_table* __t)
  {
    _V_th.insert(_V_th.begin(), __ti);
    _V_t.insert(std::make_pair(__ti,std::make_pair(__t,__t->get_change_ctr())));
    _VDBL_table::col_const_iterator __x, __e(__t->col_end());
    for(__x = __t->col_begin(); __x != __e; ++__x)
    {
      std::map<std::string,_V_colref>::iterator
                                         _ccr(_V_colnames.find((*__x).first));
      if(_ccr == _V_colnames.end())
        continue;
      _V_cx.insert(std::make_pair(std::make_pair(__ti,(*__x).second),
                                                              (*_ccr).second));
    }
    _VDBL_table::row_const_iterator __y, __f(__t->row_end());
    for(__y = __t->row_begin(); __y != __f; ++__y)
      _V_r.push_back(std::make_pair(__ti,*__y));
    std::sort(_V_r.begin(), _V_r.end());
  }

  void push_table(const _VDBL_tableid& __ti, _VDBL_table* __t,
                 const std::vector<_VDBL_rowid>& _rs)
  {
    _V_th.insert(_V_th.begin(), __ti);
    _V_t.insert(std::make_pair(__ti,std::make_pair(__t,__t->get_change_ctr())));
    _VDBL_table::col_const_iterator __x, __e(__t->col_end());
    for(__x = __t->col_begin(); __x != __e; ++__x)
    {
      std::map<std::string,_V_colref>::iterator
                                         _ccr(_V_colnames.find((*__x).first));
      if(_ccr == _V_colnames.end())
        continue;
      _V_cx.insert(std::make_pair(std::make_pair(__ti,(*__x).second),
                                                            (*_ccr).second));
    }
    std::vector<_VDBL_rowid>::const_iterator __y, __f(_rs.end());
    _V_r.reserve(_rs.size()+_V_r.size());
    for(__y = _rs.begin(); __y != __f; ++__y)
      _V_r.push_back(std::make_pair(__ti,*__y));
    std::sort(_V_r.begin(), _V_r.end());
  }

  _VDBL_tableid pop_table()
  {
    if(_V_th.empty())
      return _VDBL_tableid();
    _VDBL_tableid ti(*_V_th.begin());
    _V_th.erase(_V_th.begin());
    _V_tref::iterator _tri(_V_t.find(ti));
    if(_tri != _V_t.end())
      _V_t.erase(_tri);
    std::vector<int> erase_r;
    unsigned int j(0);
    for(unsigned int i = 0; i < _V_r.size(); ++i)
    {
      if(_V_r[i].first == ti)
        ++j;
      else if(j > 0)
        _V_r[i-j] = _V_r[i];
    }
    _V_r.erase(_V_r.end()-j, _V_r.end());
    for(_V_colxref::iterator __x = _V_colxref.begin(); __x != _V_colxref.end();
        ++__x)
    {
      if((*__x).first.first == ti)
        _V_colxref.erase(__x);
    }
    return ti;
  }

public:
  const std::type_info& get_colinfo(const std::string& _C_n,
                std::triple<bool,_VDBL_colid,_VDBL_colflags>& _r) const
  {
    std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
    if(__x == _V_colnames.end())
    {
      _r = std::make_triple(false, _VDBL_colid(), _VDBL_colflags());
      return typeid(void);
    }
    return get_master_table()->get_colinfo(_C_n, _r);
  }

  const std::type_info& get_coltype(const std::string& _C_n) const
  {
    std::triple<bool,_VDBL_colid,_VDBL_colflags> _r;
    return get_colinfo(_C_n, _r);
  }

  bool insert(const std::vector<_T_colspec>& _row)
  {
    if(view_type() != V_window)
      return false;
    _V_rowref _ri;
    std::vector<std::pair<const std::string*,const _VDBL_col*> > _v;
    _v.reserve(_row.size());
    for(std::vector<_T_colspec>::const_iterator _x = _row.begin();
        _x != _row.end(); ++_x)
      _v.push_back(std::make_pair(&(*_x).first,&(*_x).second));
    _ri.first = *_V_th.begin();
    _VDBL_table* _tp = get_table(_ri.first);
    if(!_tp) return false;
    bool ret = _tp->insert(_v, _ri.second);
    _V_r.insert(std::upper_bound(_V_r.begin(), _V_r.end(), _ri), _ri);
    return ret;
  }

  bool remove(std::pair<_VDBL_tableid,_VDBL_rowid> _r)
  {
    if(!_row_visible(_r))
      return false;
    if(view_type() != V_window)
      return false;
    _VDBL_table* _tp = get_table(_r.first);
    if(!_tp) return false;
    return _tp->remove(_r.second);
  }

  bool has_col(const std::string& _C_n) const
  {
    std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
    return __x != _V_colnames.end();
  }

  std::pair<_VDBL_tableid,_VDBL_colid> get_col_id(const std::string& _C_n) const
  {
    std::map<std::string,_V_colref>::const_iterator __x(_V_colnames.find(_C_n));
    if(__x == _V_colnames.end())
      return std::make_pair(_VDBL_tableid(),_VDBL_colid());
    return std::make_pair(get_master_table_id(),(*__x).second);
  }

  const _VDBL_row& get_row(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                           bool& error) const
  {
    if(!_row_visible(_ri))
    {
      error = true;
      return ___empty_row_return;
    }
    _VDBL_table* _tp = get_table(_ri.first);
    if(!_tp)
    {
      error = true;
      return ___empty_row_return;
    }
    return _tp->get_row(_ri.second, error);
  }
 
  const _VDBL_col& get_raw_col(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                           const _VDBL_colid& _ci, _VDBL_row const *& _rr,
                           bool& error) const
  {
    if(!_row_visible(_ri))
    {
      error = true;
      return ___empty_col_return;
    }
    _VDBL_table* _tp = get_table(_ri.first);
    if(!_tp)
    {
      error = true;
      return ___empty_col_return;
    }
    const _VDBL_row& _r(_tp->get_row(_ri.second, error));
    if(error)
      return ___empty_col_return;
    _rr = &_r;
    const _VDBL_col& _c(_r.get_col(_ci, error));
    if(error)
    {
      std::pair<_VDBL_tableid,_VDBL_colid> _tc = _find_def(_ci);
      if(_tc.first == 0)
        return ___empty_col_return;
      _tp = get_table(_tc.first);
      if(!_tp)
        return ___empty_col_return;
      return _tp->get_def(_ci, error);
    }
    else
      return _c;
  }                                             

  std::ostream& print_col(std::ostream& o,
                          const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                          const _VDBL_colid& _ci, bool& printed) const
  {
    bool error;
    const _VDBL_row* _rr;
    vdbl::col c(get_raw_col(_ri, _ci, _rr, error));
    if(error)
    {
      printed = false;
      return o;
    }
    printed = true;
    c.setcontext(_V_ctx, _rr);
    return o << c;
  }
 
  template <class _TR>
  bool get_raw_ptr(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                   const _VDBL_colid& _ci, _TR const *& r) const
  {
    bool error;
    const _VDBL_row *_rr;
    vdbl::col c(get_raw_col(_ri, _ci, _rr, error));
    if(error)
      return false;
    c.setcontext(_V_ctx, _rr);
    c.get_ptr(r);
    return true;
  }
 
  template <class _TR>
  bool get(const std::pair<_VDBL_tableid,_VDBL_rowid>& _ri,
                                 const _VDBL_colid& _ci, _TR& r) const
  {
    bool error;
    const _VDBL_row *_rr;
    vdbl::col c(get_raw_col(_ri, _ci, _rr, error));
    if(error)
      return false;
    c.setcontext(_V_ctx, _rr);
    c.get(r);
    return true;
  }
 
  const _VDBL_col& get_def(const std::pair<_VDBL_tableid,_VDBL_colid>& _ri,
                           bool& error) const
  { return get_table(_ri.first)->get_def(_ri.second, error); }

  default_const_iterator defaults_begin() const
  {
    _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
    std::pair<_VDBL_tableid,_VDBL_colid> _tc(0,0);
    while(*_rit != _V_c.end())
    {
      _tc = _find_def(**_rit);
      if(_tc.first != 0)
        break;
      ++*_rit;
    }
    if(*_rit == _V_c.end())
      return default_const_iterator(this,0,0,(void*)_rit);
    return default_const_iterator(this,_tc.first,**_rit,(void*)_rit);
  }

  default_const_iterator defaults_end() const
  {
    _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
    return default_const_iterator(this,0,0,(void*)_rit);
  }

  col_const_iterator cols_begin(const _VDBL_rowid& _r) const
  {
    _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
    std::pair<_VDBL_tableid,_VDBL_colid> _tc(0,0);
    while(*_rit != _V_c.end())
    {
      _tc = _find_col(_r,**_rit);
      if(_tc.first != 0)
        break;
      ++*_rit;
    }
    if(*_rit == _V_c.end())
      return col_const_iterator(this,0,_r,0,(void*)_rit);
    return col_const_iterator(this,_tc.first,_r,**_rit,(void*)_rit);
  }

  col_const_iterator cols_end(const _VDBL_rowid& _r) const
  {
    _V_cols::const_iterator* _rit = new _V_cols::const_iterator(_V_c.begin());
    return col_const_iterator(this,0,_r,0,(void*)_rit);
  }

  row_const_iterator rows_begin() const
  {
    _V_rows::const_iterator* _rit = new _V_rows::const_iterator(_V_r.begin());
    if(*_rit == _V_r.end())
      return row_const_iterator(this,0,0,(void*)_rit);
    return row_const_iterator(this,(**_rit).first,(**_rit).second,(void*)_rit);
  }

  row_const_iterator rows_end() const
  {
    _V_rows::const_iterator* _rit = new _V_rows::const_iterator(_V_r.end());
    return row_const_iterator(this,0,0,(void*)_rit);
  }
};


class hierarchical_view : public _VDBL_hierarchicalview
{
  typedef _VDBL_hierarchicalview _Base;

public:
  typedef _V_enum view_enum;

public:
  hierarchical_view(const _VDBL_tableid& __ti, _VDBL_table* __t,
       const _VDBL_context& __c, _V_enum __e = V_window)
                : _VDBL_hierarchicalview(__ti,__t,__c,__e) {}

  hierarchical_view(const hierarchical_view& _v) : _VDBL_hierarchicalview(_v) {}

  template <class _TR>
  bool get(const tableid& _ti, const rowid& _ri, const colid& _ci, _TR& r) const
  { return _Base::get(std::make_pair(_ti, _ri), _ci, r); }

  template <class _TR>
  bool get_raw_ptr(const tableid& _ti, const rowid& _ri, const colid& _ci,
                   _TR const *& r) const
  { return _Base::get_raw_ptr(std::make_pair(_ti, _ri), _ci, r); }


  template <class _TR>
  bool get(const rowid& _ri, const std::string& _c, _TR& r) const
  { std::pair<tableid,colid> _tci(get_col_id(_c));
    return _Base::get(std::make_pair(_tci.first, _ri), _tci.second, r); }

  template <class _TR>
  bool get(const rowid& _ri, const char* _c, _TR& r) const
  { return get(_ri, std::string(_c), r); }
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_HRVIEW_H */

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

---