net_types.h

// Copyright (C) 1999 Jean-Marc Valin & Dominic Letourneau

#ifndef _NETTYPES_H_
#define _NETTYPES_H_


#include "Object.h"
#include <iostream>
#include <string>
#include <fstream>
#include <stdio.h>
#include "ObjectPool.h"
#include "ObjectParser.h"
#include "typetraits.h"
//temporarily inserting include of Stream.h
#include "Stream.h"

namespace FD {

template <class T> 
class GenericType : public Object {

protected:

   T value;

public:
  
   typedef T basicType;

   T &val() {return value;}
   
   GenericType() {
      //value = (T) 0;
   }

   virtual ~GenericType() {;}
   
   GenericType (T val) {
      value = val;
   }
   
   GenericType (GenericType<T> &copy) {
      value = copy.value;
   }

   //static GenericType<T> *alloc()  {return ObjectPool<GenericType<T> >::alloc();}

   virtual void printOn(std::ostream &out=std::cout) const {
      out << "<Generic Type: " << typeid(T).name() << ">" << std::endl;
   }

};

template <class T>
class PrintableGenericType : public GenericType<T> {

public:

   PrintableGenericType () {}

   PrintableGenericType (T val) {
      GenericType<T>::value = val;
   }

   PrintableGenericType (PrintableGenericType<T> &copy) {
      GenericType<T>::value = copy.value;
   }

   T &val() {return GenericType<T>::value;}

   void printOn(std::ostream &out) const
   {
      out << "<" << this->className() << " " << this->value << " >";
   }

   virtual void prettyPrint(std::ostream &out=std::cout) const {
     out << this->value << " ";
   }

   void readFrom(std::istream &in)
   {
      in >> this->value;
      char ch;
      in >> ch;
      if (ch != '>')
         throw new GeneralException("Error reading String: '>' expected", __FILE__, __LINE__);
   }

   void serialize(std::ostream &out) const
   {
      out << "{" << this->className() << " |" << this->value << " }";
   }

   void unserialize(std::istream &in)
   {
      in >> this->value;
      char ch;
      in >> ch;
      if (ch != '}')
         throw new GeneralException("Error reading String: '}' expected", __FILE__, __LINE__);
   }

   //static PrintableGenericType<T> *alloc()  {return ObjectPool<PrintableGenericType<T> >::alloc();}
};

template <class T>
class NetCType : public PrintableGenericType<T> {
   
public:
   
   NetCType() {
      //casting into the type
      GenericType<T>::value = (T) 0;
   }

   NetCType(T val) { 
      GenericType<T>::value = val;
   }
   
   virtual ~NetCType() {;}
   
   operator T() {
      return GenericType<T>::value;
   }

   NetCType<T>& operator= (NetCType<T> &type) {
      GenericType<T>::value = type.value;
      return *this;
   }

   NetCType<T>& operator= (T val) {
      GenericType<T>::value = val;
      return *this;
   }

   int operator== (NetCType<T> &type) {
      return (type.value == GenericType<T>::value);
   }
   
   int operator== (T val) {
      return (GenericType<T>::value == val);
   }
   
   int operator!= (NetCType<T> &type) {
      return (type.value != GenericType<T>::value);
   }
   
   int operator!= (T val) {
      return (GenericType<T>::value != val);
   }

   static NetCType<T> *alloc()  {return ObjectPool<NetCType<T> >::alloc();}

   static NetCType<T> *alloc(const T &obj)  
   {
      NetCType<T> *ret = ObjectPool<NetCType<T> >::alloc();
      ret->value = obj;
      return ret;
   }

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

};

typedef NetCType<char> Char;

typedef NetCType<int> Int;

typedef NetCType<float> Float;

typedef NetCType<double> Double;

typedef NetCType<bool> Bool;

//typedef NetCType<FILE *> FILEPTR;
class FILEPTR : public GenericType<FILE *> {
  public: 
   FILEPTR(FILE *file);
   FILEPTR(const std::string &filename, const std::string &mode);
   ~FILEPTR();
};

#ifndef WIN32

//typedef NetCType<FILE *> FILEPTR;
class FILEDES : public GenericType<int> {
  public: 
   FILEDES(int fd);
   FILEDES(const std::string &filename, int mode);
   ~FILEDES();
};

#endif /*ifdef WIN32*/

extern ObjectRef TrueObject;

extern ObjectRef FalseObject;


class String : public std::string, public Object
{
 public:

   typedef std::string basicType;
   
   String() : std::string() {}

   void printOn(std::ostream &out) const;

   void readFrom(std::istream &in);

   void serialize(std::ostream &out) const;

   void unserialize(std::istream &in);

   void prettyPrint(std::ostream &out) const;

   String(const char *str) : std::string(str)
   {}

   String(const std::string &str) : std::string(str)
   {}
   
   const std::string& val() { return *this;}
};

std::istream &operator >> (std::istream &in, String &str);

_DEF_OBJECT_TYPE(String)

}//namespace FD
#endif

---