vdbl_expression.h

Go to the documentation of this file.

// Expression implementation -*- C++ -*-

// $Id: vdbl_expression.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_EXPRESSION_H
#define __VDBL_EXPRESSION_H

#include <algorithm>
#include <map>
#include <vector>
#include <typeinfo>
#include <vdbl_config.h>
#include <vdbl_types.h>
#include <vdbl_context.h>

__VDBL_BEGIN_NAMESPACE

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

class _VDBL_eval_expr
{
public:
}

class _VDBL_expression
{
public:
  _VDBL_expression() {}
  virtual ~_VDBL_expression() {}

  virtual const type_info& result_type() VDBL_PURE_VIRTUAL
};

class _VDBL_exprrow : public _VDBL_expression
{
  std::string _E_r;            // row name
  std::string _E_t;            // table name

public:
  _VDBL_exprrow(const std::string& __r, const std) : _C_r(__r) {}
  _VDBL_exprrow(const _VDBL_exprrow& _e) : _C_r(_e._C_r) {}
  ~_VDBL_exprrow() {}

  virtual const _VDBL_alltype_base* operator()(const _VDBL_database& _d,
                                          const _VDBL_context* _ctx) const
    {}
};

class _VDBL_exprcol : public _VDBL_expression
{
  std::string _E_c;            // col name
  std::string _E_t;            // table name

public:
  _VDBL_exprcol(const std::string& __c, const std::string& __t)
                                        : _E_c(__c), _E_t(__t) {}
  _VDBL_exprcol(const _VDBL_exprcol& _e) : _E_c(_e._E_c), _E_t(_e._E_t) {}
  ~_VDBL_exprcol() {}

  virtual const std::auto_ptr<_VDBL_alltype_base>
          operator()(const _VDBL_database& _d, const _VDBL_context* _ctx) const
    {}
};

class _VDBL_exprequal : public _VDBL_expression
{
private:
  std::auto_ptr<_VDBL_expression> _EQ_a, _EQ_b;

public:
  _VDBL_exprequal(const std::auto_ptr<_VDBL_expression>& _TA,
                  const std::auto_ptr<_VDBL_expression>& _TB)
                                         : _EQ_a(_TA), _EQ_b(_TB)
    {
      if(_TA->result_type() != _TB->result_type())
      {
        std::cerr << "VDBL exprequal: comparing different types!" <<
                std::endl;
        throw "VDBL expression: type mismatch!";
      }
    }

  const std::auto_ptr<_VDBL_alltype_base> operator()(const _VDBL_database& _d,
                                  const _VDBL_context* _ctx) const
  {
    return std::auto_ptr<_VDBL_alltype_base>
        (new _VDBL_alltype<bool>(*(*_EQ_a)(_d, _ctx) == *(*_EQ_b)(_d, _ctx)));
  }
};

class _VDBL_exprneql : public _VDBL_expression
{
private:
  std::auto_ptr<_VDBL_expression> _EQ_a, _EQ_b;

public:
  _VDBL_exprneql(const std::auto_ptr<_VDBL_expression>& _TA,
                 const std::auto_ptr<_VDBL_expression>& _TB)
                                         : _EQ_a(_TA), _EQ_b(_TB)
    {
      if(_TA->result_type() != _TB->result_type())
      {
        std::cerr << "VDBL exprequal: comparing different types!" <<
                std::endl;
        throw "VDBL expression: type mismatch!";
      }
    }

  const std::auto_ptr<_VDBL_alltype_base> operator()(const _VDBL_database& _d,
                                  const _VDBL_context* _ctx) const
  {
    return std::auto_ptr<_VDBL_alltype_base>
        (new _VDBL_alltype<bool>(*(*_EQ_a)(_d, _ctx) != *(*_EQ_b)(_d, _ctx)));
  }
};

inline std::auto_ptr<_VDBL_expression> row(const std::string& __row,
                                           const std::string& __table)
{ return std::auto_ptr<_VDBL_expression>(new _VDBL_exprrow(__row, __table)); }

inline std::auto_ptr<_VDBL_expression> row(const char* __row,
                                           const char* __table)
{ return row(std::string(__row), std::string(__table)); }

inline std::auto_ptr<_VDBL_expression> col(const std::string& __col,
                             const std::string& __table)
{ return std::auto_ptr<_VDBL_expression>(new _VDBL_exprcol(__col, __table)); }

inline std::auto_ptr<_VDBL_expression> col(const char* __col,
                                           const char* __table)
{ return col(std::string(__col), std::string(__table)); }

inline std::auto_ptr<_VDBL_expression> operator==
                        (const std::auto_ptr<_VDBL_expression>& _a,
                         const std::auto_ptr<_VDBL_expression>& _b)
{
  return std::auto_ptr<_VDBL_expression>(new _VDBL_exprequal(_a, _b));
}

typedef std::auto_ptr<_VDBL_expression> expression;

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_EXPRESSION_H */

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

---