---

addinfo.h

Go to the documentation of this file.

// Additional Information Union 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 _ADDINFO_H_
#define _ADDINFO_H_

#include <string>
#include <vector>
#include <coconut_config.h>
#include <interval.h>
#include <linalg.h>

// the simple types have to be < ADDINFO_EMPTY
#define ADDINFO_INTERVAL    -5
#define ADDINFO_DOUBLE      -4
#define ADDINFO_UINT        -3
#define ADDINFO_INT         -2
#define ADDINFO_BOOL        -1
//
#define ADDINFO_EMPTY        0
// the complex types have to be > ADDINFO_EMPTY
#define ADDINFO_ALLOCED_B    1
#define ADDINFO_ALLOCED_N    2
#define ADDINFO_ALLOCED_U    3
#define ADDINFO_ALLOCED_D    4
#define ADDINFO_ALLOCED_I    5
#define ADDINFO_ALLOCED_S    6
#define ADDINFO_ALLOCED_M    7
#define ADDINFO_ALLOCED_NM   8
#define ADDINFO_ALLOCED_IM   9

class additional_info_u
{
private:
  union
  {
    bool nb;            // this union contains additional information
    int nn;             // and standard types
    unsigned int nu;
    double nd;
    interval_st ni;
    std::string* s;
    std::vector<bool>* b;
    std::vector<int>* n;
    std::vector<unsigned int>* u;
    std::vector<double>* d;
    std::vector<interval>* i;
    matrix<double>* m;
    matrix<int>* nm;
    matrix<interval>* im;
  } __c;
  int __is_allocated;

private:
  void _destroy()
    {
      switch(__is_allocated)
      {
        case ADDINFO_INTERVAL:
        case ADDINFO_DOUBLE:
        case ADDINFO_UINT:
        case ADDINFO_INT:
        case ADDINFO_BOOL:
        case ADDINFO_EMPTY:
          break;
        case ADDINFO_ALLOCED_S:
          delete(__c.s);
          break;
        case ADDINFO_ALLOCED_B:
          delete(__c.b);
          break;
        case ADDINFO_ALLOCED_N:
          delete(__c.n);
          break;
        case ADDINFO_ALLOCED_U:
          delete(__c.u);
          break;
        case ADDINFO_ALLOCED_D:
          delete(__c.d);
          break;
        case ADDINFO_ALLOCED_I:
          delete(__c.i);
          break;
        case ADDINFO_ALLOCED_M:
          delete(__c.m);
          break;
        case ADDINFO_ALLOCED_NM:
          delete(__c.nm);
          break;
        case ADDINFO_ALLOCED_IM:
          delete(__c.im);
          break;
      }
    }

  void _copy(const additional_info_u& __a)
    {
      __is_allocated = __a.__is_allocated;
      switch(__is_allocated)
      {
        case ADDINFO_EMPTY:
          break;
        case ADDINFO_INTERVAL:
          __c.ni = __a.__c.ni;
          break;
        case ADDINFO_DOUBLE:
          __c.nd = __a.__c.nd;
          break;
        case ADDINFO_UINT:
          __c.nu = __a.__c.nu;
          break;
        case ADDINFO_INT:
          __c.nn = __a.__c.nn;
          break;
        case ADDINFO_BOOL:
          __c.nb = __a.__c.nb;
          break;
        case ADDINFO_ALLOCED_S:
          __c.s = new std::string(*__a.__c.s);
          break;
        case ADDINFO_ALLOCED_B:
          __c.b = new std::vector<bool>(*__a.__c.b);
          break;
        case ADDINFO_ALLOCED_N:
          __c.n = new std::vector<int>(*__a.__c.n);
          break;
        case ADDINFO_ALLOCED_U:
          __c.u = new std::vector<unsigned int>(*__a.__c.u);
          break;
        case ADDINFO_ALLOCED_D:
          __c.d = new std::vector<double>(*__a.__c.d);
          break;
        case ADDINFO_ALLOCED_I:
          __c.i = new std::vector<interval>(*__a.__c.i);
          break;
        case ADDINFO_ALLOCED_M:
          __c.m = new matrix<double>(*__a.__c.m);
          break;
        case ADDINFO_ALLOCED_NM:
          __c.nm = new matrix<int>(*__a.__c.nm);
          break;
        case ADDINFO_ALLOCED_IM:
          __c.im = new matrix<interval>(*__a.__c.im);
          break;
      }
    }

public:
  additional_info_u() : __is_allocated(ADDINFO_EMPTY) {}
  additional_info_u(bool __x) : __is_allocated(ADDINFO_BOOL)
    { __c.nb = __x; }
  additional_info_u(int __x) : __is_allocated(ADDINFO_INT)
    { __c.nn = __x; }
  additional_info_u(unsigned int __x) : __is_allocated(ADDINFO_UINT)
    { __c.nu = __x; }
  additional_info_u(double __x) : __is_allocated(ADDINFO_DOUBLE)
    { __c.nd = __x;}
  additional_info_u(interval __x) : __is_allocated(ADDINFO_INTERVAL)
    { __c.ni = __x; }
  additional_info_u(const char* __cp) : __is_allocated(ADDINFO_ALLOCED_S)
    { __c.s = new std::string(__cp); }
  additional_info_u(const std::string& __x) : __is_allocated(ADDINFO_ALLOCED_S)
    { __c.s = new std::string(__x); }
  additional_info_u(const std::vector<bool>& __x) : __is_allocated(ADDINFO_ALLOCED_B)
    { __c.b = new std::vector<bool>(__x); }
  additional_info_u(const std::vector<int>& __x) : __is_allocated(ADDINFO_ALLOCED_N)
    { __c.n = new std::vector<int>(__x); }
  additional_info_u(const std::vector<unsigned int>& __x) : __is_allocated(ADDINFO_ALLOCED_U)
    { __c.u = new std::vector<unsigned int>(__x); }
  additional_info_u(const std::vector<double>& __x) :
        __is_allocated(ADDINFO_ALLOCED_D)
    { __c.d = new std::vector<double>(__x); }
  additional_info_u(const std::vector<interval>& __x) :
        __is_allocated(ADDINFO_ALLOCED_I)
    { __c.i = new std::vector<interval>(__x); }
  additional_info_u(const matrix<double>& __x) :
        __is_allocated(ADDINFO_ALLOCED_M)
    { __c.m = new matrix<double>(__x); }
  additional_info_u(const matrix<int>& __x) :
        __is_allocated(ADDINFO_ALLOCED_NM)
    { __c.nm = new matrix<int>(__x); }
  additional_info_u(const matrix<interval>& __x) :
        __is_allocated(ADDINFO_ALLOCED_IM)
    { __c.im = new matrix<interval>(__x); }

  ~additional_info_u()
    { _destroy(); }
  
  additional_info_u(const additional_info_u& __a)
    { _copy(__a); }

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

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

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

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

  additional_info_u& operator=(interval __x)
    { _destroy(); __is_allocated = ADDINFO_INTERVAL; __c.ni = __x;
      return *this;
    }

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

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

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

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

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

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

  additional_info_u& operator=(const std::vector<interval>& __x)
    { _destroy(); __is_allocated = ADDINFO_ALLOCED_I;
      __c.i = new std::vector<interval>(__x);
      return *this;
    }

  additional_info_u& operator=(const matrix<double>& __x)
    { _destroy(); __is_allocated = ADDINFO_ALLOCED_M;
      __c.m = new matrix<double>(__x);
      return *this;
    }

  additional_info_u& operator=(const matrix<int>& __x)
    { _destroy(); __is_allocated = ADDINFO_ALLOCED_NM;
      __c.nm = new matrix<int>(__x);
      return *this;
    }

  additional_info_u& operator=(const matrix<interval>& __x)
    { _destroy(); __is_allocated = ADDINFO_ALLOCED_IM;
      __c.im = new matrix<interval>(__x);
      return *this;
    }

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

  additional_info_u& clear()
    {
      _destroy();
      __is_allocated = ADDINFO_EMPTY;
      return *this;
    }

public:
  // this constructor must not be used unless __m was allocated
  // by new matrix<double>.
  additional_info_u& set_m(matrix<double>* __m)
  {
    clear();
    __is_allocated = ADDINFO_ALLOCED_M;
    __c.m = __m;
    return *this;
  }
  
  // this constructor must not be used unless __m was allocated
  // by new matrix<interval>.
  additional_info_u& set_im(matrix<interval>* __m)
  {
    clear();
    __is_allocated = ADDINFO_ALLOCED_IM;
    __c.im = __m;
    return *this;
  }
  
  // this constructor must not be used unless __m was allocated
  // by new matrix<int>.
  additional_info_u& set_nm(matrix<int>* __m)
  {
    clear();
    __is_allocated = ADDINFO_ALLOCED_NM;
    __c.nm = __m;
    return *this;
  }
  
public:
  bool nb() const { return __c.nb; }
  int nn() const { return __c.nn; }
  unsigned int nu() const { return __c.nu; }
  double nd() const { return __c.nd; }
  interval ni() const { return __c.ni; }
  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<unsigned int>& u() const { return *__c.u; }
  std::vector<double>& d() const { return *__c.d; }
  std::vector<interval>& i() const { return *__c.i; }
  matrix<double>& m() const { return *__c.m; }
  matrix<int>& nm() const { return *__c.nm; }
  matrix<interval>& im() const { return *__c.im; }

  bool is_allocated() const { return __is_allocated > ADDINFO_EMPTY; }
  bool empty() const { return __is_allocated == ADDINFO_EMPTY; }
  int has_type() { return __is_allocated; }
};

#endif /* _ADDINFO_H_ */

---