Complex.h

#ifndef _COMPLEX_H_
#define _COMPLEX_H_


#include "Object.h"
#include <iostream>
#include "ObjectPool.h"
#include "ObjectParser.h"
#include "typetraits.h"
#include <complex>
#include "binio.h"
#include "net_types.h"

namespace FD {

template <class T>
class Complex : public std::complex<T>, public Object {

 public:

  typedef std::complex<T> basicType;
  
  Complex() : std::complex<T>() {}
  
  Complex(const std::complex<T> &val) : std::complex<T>(val) {}

  Complex(const Complex<T> &val) : std::complex<T>(val) {}

  Complex(const NetCType<std::complex<T> > &obj) : std::complex<T>(obj.val()) {}

  void printOn(std::ostream &out) const {
    out << "<"<<className()<<" ";
    out << *((std::complex<T>*) this);
    out << ">"<<std::endl;
  }
  
  void readFrom(std::istream &in) {
    std::complex<T> value;
    in >> value;
    *this = value;
    char ch;
    in >> ch;
    if (ch != '>') {
      throw new GeneralException(std::string("Error reading ") + className() + std::string(" > expected"), __FILE__, __LINE__);
    }
  }
  
  void serialize(std::ostream &out) const {
    out << "{" << className() << " |";
    BinIO::write(out, (std::complex<T>*) this, 1);
    out << " }";
  }
  
  void unserialize(std::istream &in) { 
    std::complex<T> value;
    BinIO::read(in, &value, 1);
    *this = value;    
    char ch;
    in >> ch;
    if (ch != '}') {
       throw new GeneralException(std::string("Error reading ") + className() + std::string(" } expected"), __FILE__, __LINE__);
    }    
  }
  
  void prettyPrint(std::ostream &out) const { 
    out << *((std::complex<T>*) this);
  }
  
  std::complex<T>& val() const {return *((std::complex<T>*) this);}
  
  
  static Complex<T> *alloc()  {return ObjectPool<Complex<T> >::alloc();}
  
  static Complex<T> *alloc(const Complex<T> &obj)  
  {
    Complex<T> *ret = ObjectPool<Complex<T> >::alloc();
    *ret = obj;
    return ret;
  }

  void destroy() {ObjectPool<Complex<T> >::release(this);}

  virtual ObjectRef clone() {
    return ObjectRef(Complex<T>::alloc(*(std::complex<T>*) this));
  }

};

template <class T> 
std::istream &operator >> (std::istream &in, Complex<T> &value) { 
  
  char ch;
  in >> ch;
  
  std::string expected = ObjectGetClassName<Complex<T> >();
  
  if (ch == '<') {
    std::string type;
    in >> type;
    
    if (expected != type) {
      throw new ParsingException ("Parser expected type " + expected + " and got " + type);
    }

    //reading object
    value.readFrom(in);
  }
  else if (ch == '{') {
    std::string type;
    in >> type;

    if (expected != type) {
      throw new ParsingException ("Parser expected type " + expected + " and got " + type);
    }
    
    //reading dummy spaces
    char dummy;      
    do {
      in >> dummy;
    } while(dummy != '|');

    value.unserialize(in);

  } else {
    throw new ParsingException ("Parser expected < or { while parsing type " + expected);
  }

  return in;
}

_DEF_OBJECT_TYPE(Complex<float>)
_DEF_OBJECT_TYPE(Complex<double>)

}//namespace FD
#endif

---