---

vdbl_col.h

Go to the documentation of this file.

// Column class implementation -*- C++ -*-

// 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_COL_H
#define __VDBL_COL_H

#include <stddef.h>
#include <typeinfo>
#include <iostream>
#include <vdbl_config.h>
#include <vdbl_types.h>
#include <vdbl_context.h>
#include <vdbl_alltype.h>

__VDBL_BEGIN_NAMESPACE

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

template <class _C>
inline std::ostream& print_it(std::ostream& o, const _C& t)
{
  return o << t;
}


class _VDBL_row;
class row;


class __VDBL_colbase
{
public:

  __VDBL_colbase() {}
  __VDBL_colbase(const __VDBL_colbase& __v) {}
  virtual ~__VDBL_colbase() {}

  virtual __VDBL_colbase* new_copy() const { return new __VDBL_colbase(*this); }

  virtual void setcontext(const context* _c, const _VDBL_row* _r) VDBL_PURE_VIRTUAL

  virtual void get_copy(_VDBL_alltype_base* c) const VDBL_PURE_VIRTUAL

  virtual void def_copy(_VDBL_alltype_base* d) const VDBL_PURE_VIRTUAL

  virtual const std::type_info& return_type_id() const VDBL_PURE_VIRTUAL

  virtual std::ostream& print_contents(std::ostream& o) const VDBL_PURE_VIRTUAL
};


template <class _R>
class _VDBL_colbase : public __VDBL_colbase
{
public:
  typedef _R return_type;
  typedef _VDBL_colbase<_R> _Self;
  typedef __VDBL_colbase _Base;


  _VDBL_colbase() {}
  _VDBL_colbase(const _Self& __c) {}
  virtual ~_VDBL_colbase() {}

  virtual _Self* new_copy() const { return new _VDBL_colbase(*this); }
  
  virtual void setcontext(const context* _c, const _VDBL_row* _r) VDBL_PURE_VIRTUAL

  virtual void get(return_type& c) const VDBL_PURE_VIRTUAL

  virtual void def(return_type& d) const VDBL_PURE_VIRTUAL

  virtual void get_ptr(return_type const *& c) const VDBL_PURE_VIRTUAL

  virtual void get_copy(return_type*& c) const
  { c = new return_type(); get(*c); }

  virtual void def_copy(return_type*& d) const
  { d = new return_type(); def(*d); }

  virtual void get_copy(_VDBL_alltype_base*& v) const
  {
    return_type *c = new return_type();
    get(*c);
    v = (_VDBL_alltype_base *) new _VDBL_alltype<return_type>(c);
  }

  virtual void def_copy(_VDBL_alltype_base*& v) const
  {
    return_type *d = new return_type();
    def(*d);
    v = (_VDBL_alltype_base *) new _VDBL_alltype<return_type>(d);
  }

  virtual const std::type_info& return_type_id() const
  { return typeid(return_type); }

  virtual std::ostream& print_contents(std::ostream& o) const VDBL_PURE_VIRTUAL
};


class _VDBL_col
{
private:
  __VDBL_colbase* _C_p;

public:
  _VDBL_col() : _C_p(NULL) {}
  _VDBL_col(const _VDBL_col& __c);
  explicit _VDBL_col(__VDBL_colbase* __p) : _C_p(__p) {}

  template <class _RR>
  explicit _VDBL_col(const _RR& _c);
  
  virtual ~_VDBL_col();

  void setcontext(const context* _c, const _VDBL_row* _r);

  template <class _R>
  void set(_VDBL_colbase<_R>* _p) { _C_p = (__VDBL_colbase*)_p; }

  template <class _R>
  void get(_R& c) const;

  template <class _R>
  void def(_R& d) const;

  template <class _R>
  void get_ptr(_R const *& c) const;

  template <class _R>
  void get_copy(_R*& p) const;

  template <class _R>
  void def_copy(_R*& p) const;

  void get_copy(_VDBL_alltype_base*& v) const;

  void def_copy(_VDBL_alltype_base*& d) const;

  const std::type_info& return_type_id() const
  { return _C_p->return_type_id(); }

  const __VDBL_colbase* get_ptr_to_val() const
  { return _C_p; }

  friend std::ostream& operator<<(std::ostream& o, const _VDBL_col& c);
};

inline std::ostream& operator<<(std::ostream& o, const _VDBL_col& c)
{
  return c._C_p->print_contents(o);
}

template <class _RR>
inline _VDBL_col::_VDBL_col(const _RR& _c)
        { _C_p = (__VDBL_colbase*)(((__VDBL_colbase*)(&_c))->new_copy()); }

inline _VDBL_col::_VDBL_col(const _VDBL_col& __c)
        { _C_p = __c._C_p ? __c._C_p->new_copy() : NULL; }

inline _VDBL_col::~_VDBL_col() { delete _C_p; }

inline void _VDBL_col::setcontext(const context* _c, const _VDBL_row* _r) { _C_p->setcontext(_c, _r); }

template <class _R>
inline void _VDBL_col::get(_R& c) const { ((_VDBL_colbase<_R>*)_C_p)->get(c); }

template <class _R>
inline void _VDBL_col::def(_R& c) const { ((_VDBL_colbase<_R>*)_C_p)->def(c); }

template <class _R>
inline void _VDBL_col::get_ptr(_R const *& c) const
{ ((_VDBL_colbase<_R>*)_C_p)->get_ptr(c); }

template <class _R>
inline void _VDBL_col::get_copy(_R*& c) const
{ ((_VDBL_colbase<_R>*)_C_p)->get_copy(c); }

template <class _R>
inline void _VDBL_col::def_copy(_R*& c) const
{ ((_VDBL_colbase<_R>*)_C_p)->def_copy(c); }

inline void _VDBL_col::get_copy(_VDBL_alltype_base*& v) const
{ _C_p->get_copy(v); }

inline void _VDBL_col::def_copy(_VDBL_alltype_base*& v) const
{ _C_p->def_copy(v); }


template <class _T>
class _VDBL_stdcol : public _VDBL_colbase<_T>
{
private:
  typedef _VDBL_colbase<_T> _Base;
  typedef _VDBL_stdcol<_T> _Self;

  typedef typename _Base::return_type return_type;

  typedef _T type;      

  type _C_t;            

public:

  _VDBL_stdcol() : _Base(), _C_t() {}
  _VDBL_stdcol(const _Self& __c) : _Base(__c), _C_t(__c._C_t) {}
  virtual ~_VDBL_stdcol() {}

  _VDBL_stdcol(const type& __t) : _Base(), _C_t(__t) {}
  
  _Self* new_copy() const { return new _Self(*this); }

  void set(const _Self& _p) { _C_t = _p._C_t; }

  void setcontext(const context* _c, const _VDBL_row* _r) {}

  void get(type& c) const { c = _C_t; }
  
  void def(type& d) const { d = _C_t; }

  void get_ptr(type const *& c) const { c = &_C_t; }
  
  void get_copy(return_type*& c) const
  { c = new return_type(_C_t); }

  void def_copy(return_type*& d) const
  { d = new return_type(_C_t); }

  void get_copy(_VDBL_alltype_base*& v) const
  {
    return_type *c;
    get_copy(c);
    v = (_VDBL_alltype_base *) new _VDBL_alltype<return_type>(c);
  }

  void def_copy(_VDBL_alltype_base*& v) const
  {
    return_type *d;
    def_copy(d);
    v = (_VDBL_alltype_base *) new _VDBL_alltype<return_type>(d);
  }

  void set(const type& __t) { _C_t = __t; }

  void set_default(const type& __t) { _C_t = __t; }

  const type& get_val() const { return _C_t; }

  std::ostream& print_contents(std::ostream& o) const { return o << _C_t; }
};


template <class _C, class _M, class _R>
class _VDBL_mthdcol : public _VDBL_colbase<_R>
{
private:
  typedef _VDBL_colbase<_R> _Base;
  typedef _VDBL_mthdcol<_C,_M,_R> _Self;

  typedef typename _Base::return_type return_type;

  typedef _M method;
  typedef _R type;
  typedef _C real_context;

  method _C_m;      

public:

  _VDBL_mthdcol() : _Base(), _C_m() {}
  _VDBL_mthdcol(const _Self& __c) : _Base(__c), _C_m(__c._C_m) {}
  virtual ~_VDBL_mthdcol() {}
  
  _VDBL_mthdcol(const method& __m) : _Base(), _C_m(__m) {}
  
  _Self* new_copy() const { return new _Self(*this); }

  virtual void setcontext(const context* _c, const _VDBL_row* _r)
        { _C_m.setcontext((real_context*)_c, (const row*) _r); }

  void get(type& c) const
  { c = _C_m(); }

  void get_ptr(type const *& c) const
  { c = NULL; }

  void def(type& d) const
  { d = _C_m.def(); }
  
  void get_copy(return_type*& c) const
  { c = new return_type(_C_m()); }

  void def_copy(return_type*& d) const
  { d = new return_type(_C_m.def()); }

  std::ostream& print_contents(std::ostream& o) const { return o << _C_m(); }
};


typedef _VDBL_col col;


typedef _VDBL_stdcol<mixtype> standard_col;


template <class _R>
class col_base : public _VDBL_colbase<_R>
{
public:
  typedef _R return_type;
};


template <class _T>
class typed_col : public _VDBL_stdcol<_T>
{
private:
  typedef _VDBL_stdcol<_T> _Base;
  typedef typed_col<_T> _Self;
public:
  typedef _T type;
  typedef _T return_type;

  typed_col() : _Base() {}
  typed_col(const _T& __t) : _Base(__t) {}
  typed_col(const _Self& __t) : _Base(__t) {}

  virtual ~typed_col() {}
};


template <class _M>
class method_col : public _VDBL_mthdcol<typename _M::context, _M,
                                        typename _M::return_type>
{
private:
  typedef _VDBL_mthdcol<typename _M::context, _M, typename _M::return_type>
                                                                        _Base;
  typedef method_col<_M> _Self;

public:
  typedef _M method;
  typedef typename _M::return_type return_type;
  typedef typename _M::context context;

  method_col() : _Base() {}
  method_col(const _Self& __m) : _Base(__m) {}
  method_col(const method& __m) : _Base(__m) {}

  virtual ~method_col() {}
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_COL_H */

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

---