---

dbtools.h

Go to the documentation of this file.

// Database Tools implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the COCONUT API.  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 _DBTOOLS_H_
#define _DBTOOLS_H_

#include <list>
#include <database>
#include <db_method>

class work_node_context : public vdbl::context
{
  const gptr<work_node>* __wn;

public:
  work_node_context() : __wn(NULL) {}
  work_node_context(const gptr<work_node>* _i) : __wn(_i) {}
  work_node_context(const work_node_context& _w) : __wn(_w.__wn) {}
  virtual ~work_node_context() {}

  work_node_context& operator=(const work_node_context& _w)
        { __wn = _w.__wn; return *this; }

  const gptr<work_node>* wn() const { return __wn; }
};

class point_check_feasibility : public vdbl::method<bool>
{
public:
  typedef work_node_context context;

private:
  typedef vdbl::method<bool> _Base;
  vdbl::colid x_ci, L_ci, f_ci;
  const vdbl::row* _r;
  const work_node_context* wnc;

public:
  typedef bool return_type;

  point_check_feasibility(vdbl::colid _x, vdbl::colid _L, vdbl::colid _f)
        : _Base(), x_ci(_x), L_ci(_L), f_ci(_f), _r(), wnc(NULL) {}
  point_check_feasibility(const point_check_feasibility& _i)
        : _Base(_i), x_ci(_i.x_ci), L_ci(_i.L_ci), f_ci(_i.f_ci), _r(_i._r),
          wnc(_i.wnc) {}
  virtual ~point_check_feasibility() {}

  bool operator() () const;
  bool def() const { return operator()(); }
  void setcontext(const context* c, const vdbl::row* r)
       { _r = r; wnc = (work_node_context *) c; }
};

class box_check_intersection : public vdbl::method<bool>
{
public:
  typedef work_node_context context;

private:
  typedef vdbl::method<bool> _Base;
  vdbl::colid x_ci;
  const vdbl::row* _r;
  const work_node_context* wnc;

public:
  typedef bool return_type;

  box_check_intersection(vdbl::colid _x)
        : _Base(), x_ci(_x), _r(), wnc(NULL) {}
  box_check_intersection(const box_check_intersection& _i)
        : _Base(_i), x_ci(_i.x_ci), _r(_i._r), wnc(_i.wnc) {}
  virtual ~box_check_intersection() {}

  bool operator() () const;
  bool def() const { return operator()(); }
  void setcontext(const context* c, const vdbl::row* r)
       { _r = r; wnc = (work_node_context *) c; }
};

typedef std::list<vdbl::col_spec> dbt_row;

template < class _C >
inline void add_to_dbt_row(dbt_row& dbr, const std::string& nm, const _C& cont)
{
  dbr.push_back(vdbl::col_spec(nm, vdbl::col(vdbl::typed_col<_C>(cont))));
}

template < class _C >
inline void add_to_dbt_row(dbt_row& dbr, const char* nm, const _C& cont)
{
  add_to_dbt_row(dbr, std::string(nm), cont);
}

#endif // _DBTOOLS_H

---