---

vdbl_alltype.h

Go to the documentation of this file.

// All-Type 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_ALLTYPE_H
#define __VDBL_ALLTYPE_H

#include <vdbl_config.h>
#include <vdbl_types.h>
#include <string>
#include <vector>
#include <typeinfo>

__VDBL_BEGIN_NAMESPACE

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



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

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


  virtual bool operator==(const _VDBL_alltype_base &p) VDBL_PURE_VIRTUAL
  virtual bool operator!=(const _VDBL_alltype_base &p) VDBL_PURE_VIRTUAL
};


template <class _R>
class _VDBL_alltype : public _VDBL_alltype_base
{
public:
  typedef _R cont_type;

private:
  typedef _VDBL_alltype<_R> _Self;

private:
  cont_type* _RC_p;

public:
  _VDBL_alltype() : _RC_p(NULL) {}

  _VDBL_alltype(const cont_type& _p) : _RC_p(new cont_type(_p)) {}

  _VDBL_alltype(cont_type* _p) : _RC_p(_p) {}

  virtual ~_VDBL_alltype() { delete _RC_p; }

  const std::type_info& get_type() const { return typeid(_R); }

  const cont_type& content() const { return *_RC_p; }
  

  void operator=(const void *p)
        { delete _RC_p; _RC_p = new cont_type((cont_type*) p); }
  
  void operator=(const cont_type *p)
        { delete _RC_p; _RC_p = new cont_type((cont_type*) p); }


  bool operator==(const _Self &p)
        { return *_RC_p == p; }

  bool operator!=(const _Self &p)
        { return *_RC_p != p; }
};

class _VDBL_dateinterval;


class _VDBL_date
{
public:
  int timezone;

  int year;
  signed char month, day;
  unsigned int seconds;
  unsigned int microseconds;

  _VDBL_dateinterval operator-(const _VDBL_date& _v) const;


  _VDBL_date& operator-(const _VDBL_dateinterval& _v) const;
  _VDBL_date& operator-=(const _VDBL_dateinterval& _v);
  _VDBL_date& operator+(const _VDBL_dateinterval& _v) const;
  _VDBL_date& operator+=(const _VDBL_dateinterval& _v);

#if 0
  _VDBL_date& operator=(const _VDBL_date& _v)
  {
    timezone = _v.timezone;
    year = _v.year;
    month = _v.month;
    day = _v.day;
    seconds = _v.seconds;
    microseconds = _v.microseconds;
    return *this;
  }
#endif
};

#if 0
_VDBL_date& operator=(_VDBL_date& _a, const _VDBL_date& _v)
{
  _a.timezone = _v.timezone;
  _a.year = _v.year;
  _a.month = _v.month;
  _a.day = _v.day;
  _a.seconds = _v.seconds;
  _a.microseconds = _v.microseconds;
  return _a;
}
#endif


class _VDBL_dateinterval
{
public:

  int years;
  short int days;
  int seconds;
  int microseconds;
  

  _VDBL_dateinterval operator*(double d) const;
  _VDBL_dateinterval operator/(double d) const;
  _VDBL_dateinterval& operator*=(double d);
  _VDBL_dateinterval& operator/=(double d);


  _VDBL_dateinterval& operator-(const _VDBL_dateinterval& _v) const;
  _VDBL_dateinterval& operator-=(const _VDBL_dateinterval& _v);
  _VDBL_dateinterval& operator+(const _VDBL_dateinterval& _v) const;
  _VDBL_dateinterval& operator+=(const _VDBL_dateinterval& _v);

  _VDBL_date operator+(const _VDBL_date& _d) const;
};
  
#if 0
_VDBL_dateinterval& operator=(_VDBL_dateinterval& _a,
                              const _VDBL_dateinterval& _v)
{
  _a.years = _v.years;
  _a.days = _v.days;
  _a.seconds = _v.seconds;
  _a.microseconds = _v.microseconds;
  return _a;
}
#endif


class _VDBL_mixtype
{
public:

#define VDBL_MIXTYPE_EMPTY        -1
#define VDBL_MIXTYPE_ALLOCED_NONE 0
#define VDBL_MIXTYPE_ALLOCED_B    1
#define VDBL_MIXTYPE_ALLOCED_N    2
#define VDBL_MIXTYPE_ALLOCED_D    3
#define VDBL_MIXTYPE_ALLOCED_U    4
#define VDBL_MIXTYPE_ALLOCED_S    5


private:
  union
  {
    bool nb;            
    int nn;             
    unsigned int nu;
    double nd;
    _VDBL_date dt;
    _VDBL_dateinterval di;
    std::string* s;
    std::vector<bool>* b;
    std::vector<int>* n;
    std::vector<unsigned int>* u;
    std::vector<double>* d;
  } __c;
  int __is_allocated;

private:
  void _destroy()
    {
      switch(__is_allocated)
      {
        case VDBL_MIXTYPE_EMPTY:
        case VDBL_MIXTYPE_ALLOCED_NONE:
          break;
        case VDBL_MIXTYPE_ALLOCED_S:
          delete(__c.s);
          break;
        case VDBL_MIXTYPE_ALLOCED_B:
          delete(__c.b);
          break;
        case VDBL_MIXTYPE_ALLOCED_N:
          delete(__c.n);
          break;
        case VDBL_MIXTYPE_ALLOCED_D:
          delete(__c.d);
          break;
        case VDBL_MIXTYPE_ALLOCED_U:
          delete(__c.u);
          break;
      }
    }

  void _copy(const _VDBL_mixtype& __a)
    {
      __is_allocated = __a.__is_allocated;
      switch(__is_allocated)
      {
        case VDBL_MIXTYPE_EMPTY:
          break;
        case VDBL_MIXTYPE_ALLOCED_NONE:
          __c = __a.__c;
          break;
        case VDBL_MIXTYPE_ALLOCED_S:
          __c.s = new std::string(*__a.__c.s);
          break;
        case VDBL_MIXTYPE_ALLOCED_B:
          __c.b = new std::vector<bool>(*__a.__c.b);
          break;
        case VDBL_MIXTYPE_ALLOCED_N:
          __c.n = new std::vector<int>(*__a.__c.n);
          break;
        case VDBL_MIXTYPE_ALLOCED_D:
          __c.d = new std::vector<double>(*__a.__c.d);
          break;
        case VDBL_MIXTYPE_ALLOCED_U:
          __c.u = new std::vector<unsigned int>(*__a.__c.u);
          break;
      }
    }

public:

  _VDBL_mixtype() : __is_allocated(VDBL_MIXTYPE_EMPTY) {}
  _VDBL_mixtype(bool __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_NONE)
    { __c.nb = __x; }
  _VDBL_mixtype(int __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_NONE)
    { __c.nn = __x; }
  _VDBL_mixtype(double __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_NONE)
    { __c.nd = __x;}
  _VDBL_mixtype(unsigned int __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_NONE)
    { __c.nu = __x; }
  _VDBL_mixtype(_VDBL_date __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_NONE)
    { __c.dt = __x; }
  _VDBL_mixtype(_VDBL_dateinterval __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_NONE)
    { __c.di = __x; }
  _VDBL_mixtype(const char* __cp) : __is_allocated(VDBL_MIXTYPE_ALLOCED_S)
    { __c.s = new std::string(__cp); }
  _VDBL_mixtype(const std::string& __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_S)
    { __c.s = new std::string(__x); }
  _VDBL_mixtype(const std::vector<bool>& __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_B)
    { __c.b = new std::vector<bool>(__x); }
  _VDBL_mixtype(const std::vector<int>& __x) : __is_allocated(VDBL_MIXTYPE_ALLOCED_N)
    { __c.n = new std::vector<int>(__x); }
  _VDBL_mixtype(const std::vector<double>& __x) :
        __is_allocated(VDBL_MIXTYPE_ALLOCED_D)
    { __c.d = new std::vector<double>(__x); }
  _VDBL_mixtype(const std::vector<unsigned int>& __x) :
        __is_allocated(VDBL_MIXTYPE_ALLOCED_U)
    { __c.u = new std::vector<unsigned int>(__x); }

  virtual ~_VDBL_mixtype()
    { _destroy(); }
  
  _VDBL_mixtype(const _VDBL_mixtype& __a)
    { _copy(__a); }


  _VDBL_mixtype& operator=(bool __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_NONE; __c.nb = __x;
      return *this;
    }

  _VDBL_mixtype& operator=(int __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_NONE; __c.nn = __x;
      return *this;
    }

  _VDBL_mixtype& operator=(double __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_NONE; __c.nd = __x;
      return *this;
    }

  _VDBL_mixtype& operator=(unsigned int __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_NONE; __c.nu = __x;
      return *this;
    }

  _VDBL_mixtype& operator=(const _VDBL_date& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_NONE; __c.dt = __x;
      return *this;
    }

  _VDBL_mixtype& operator=(const _VDBL_dateinterval& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_NONE; __c.di = __x;
      return *this;
    }

  _VDBL_mixtype& operator=(const std::string& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_S;
      __c.s = new std::string(__x);
      return *this;
    }

  _VDBL_mixtype& operator=(const char* __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_S;
      __c.s = new std::string(__x);
      return *this;
    }

  _VDBL_mixtype& operator=(const std::vector<bool>& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_B;
      __c.b = new std::vector<bool>(__x);
      return *this;
    }

  _VDBL_mixtype& operator=(const std::vector<int>& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_N;
      __c.n = new std::vector<int>(__x);
      return *this;
    }

  _VDBL_mixtype& operator=(const std::vector<double>& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_D;
      __c.d = new std::vector<double>(__x);
      return *this;
    }

  _VDBL_mixtype& operator=(const std::vector<unsigned int>& __x)
    { _destroy(); __is_allocated = VDBL_MIXTYPE_ALLOCED_U;
      __c.u = new std::vector<unsigned int>(__x);
      return *this;
    }

  _VDBL_mixtype& operator=(const _VDBL_mixtype& __a)
    {
      _destroy();
      _copy(__a);
      return *this;
    }

  _VDBL_mixtype& clear()
    {
      _destroy();
      __is_allocated = VDBL_MIXTYPE_EMPTY;
      return *this;
    }

public:

  bool nb() const { return __c.nb; }
  int nn() const { return __c.nn; }
  double nd() const { return __c.nd; }
  unsigned int nu() const { return __c.nu; }
  _VDBL_date dt() const { return __c.dt; }
  _VDBL_dateinterval di() const { return __c.di; }
  std::string& s() const { return *__c.s; }
  std::vector<bool>& b() const { return *__c.b; }
  std::vector<int>& n() const { return *__c.n; }
  std::vector<double>& d() const { return *__c.d; }
  std::vector<unsigned int>& u() const { return *__c.u; }

  bool is_vector() const { return __is_allocated != VDBL_MIXTYPE_ALLOCED_NONE &&
                                  __is_allocated != VDBL_MIXTYPE_EMPTY; }
  
  bool empty() const { return __is_allocated == VDBL_MIXTYPE_EMPTY; }
};


typedef _VDBL_date date;

typedef _VDBL_dateinterval dateinterval;

typedef _VDBL_mixtype mixtype;


typedef _VDBL_alltype_base alltype_base;


template <class _T>
class alltype : public _VDBL_alltype<_T>
{
private:
  typedef _VDBL_alltype<_T> _Base;

public:
  typedef typename _Base::cont_type cont_type;
};

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

__VDBL_END_NAMESPACE

#endif /* __VDBL_ALLTYPE_H */

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

---