---

polymorph.h

Go to the documentation of this file.

#ifndef ___POLYMORPH_H___
#define ___POLYMORPH_H___

#include <cstring>
#include <string>
using std::string;
#include <typeinfo>
#include <cassert>

#include "../src/stringutils.h"
#include "../src/stringparser.h"
#include "../src/allocatingpointer.h"
#include "../src/tristate.h"
#include "../src/typeless.h"


#ifdef ANSI_COMPATIBLE
/* Optional: defines LONG_DOUBLE_UNAVAILABLE where needed */
#include "../src/ind_types.h"
#endif



/* Forward declaration */
template <class T>  class Polymorph;


template <class T>
class PolymorphBase : public Typeless {
public:
  typedef T value_type;
  typedef  PolymorphBase<value_type> self;
  virtual ~PolymorphBase() { }

  PolymorphBase(const value_type  val) : p(val) {  };
  PolymorphBase(      value_type* ptr) : p(ptr) {  };

  virtual bool operator<  (const Typeless&   o) const;
  virtual bool operator>  (const Typeless&   o) const;

  bool operator<  (const self&       o) const {  return (*p < *(o.p));  }
  bool operator>  (const self&       o) const {  return (*p > *(o.p));  }

  bool operator<  (const value_type& o) const {  return (*p <   o   );  }
  bool operator>  (const value_type& o) const {  return (*p >   o   );  }

  self&     operator= (const value_type& o) {  p=o;  return *this;  }
  Typeless& set(const Typeless&   o);
  
  const value_type& operator* () const {  return *p;  }
  
  value_type* valueptr() const {  return p.valueptr();  }

  virtual string stringrep(String::StreamFormat format=String::StreamFormat()) const
    {  return String::stringrep(*p,format);  }
  
  virtual string typestring() const
    {  return (name_str? string(name_str) : string(typeid(T).name()));  }

  static void set_typestring(const char* str) {  name_str=str;  }

  virtual Typeless* parse(const StringParser& parser, const string& s) const {
    value_type result;
    (void)parser; (void)s;
    parser.parse(s,result);
    return new Polymorph<value_type>(result); 
  }

  virtual Typeless* clone() const { return new self(*this); };

  virtual Typeless* duplicate() const { return new self(*p); };

protected:
  AllocatingPointer<value_type> p;
  
  static const char* name_str;
};



/* Static variables */
template <class T>
const char* PolymorphBase<T>::name_str=0;



template <class T>
bool PolymorphBase<T>::operator<  (const Typeless&   o) const
{
  /* First try to match exact type */
  const self* oself = dynamic_cast<const self*>(&o);
  if (oself) return (*this < **oself);
  
  /* Fall back to numeric comparison if both are numbers */
  if (isnumeric() && o.isnumeric())
    return (numericvalue() < o.numericvalue());
  
  assert(0); /* Unsupported comparison */
  exit(-1);
  return true;
}



template <class T>
bool PolymorphBase<T>::operator>  (const Typeless&   o) const
{
  /* First try to match exact type */
  const self* oself = dynamic_cast<const self*>(&o);
  if (oself) return (*this > **oself);
  
  /* Fall back to numeric comparison if both are numbers */
  if (isnumeric() && o.isnumeric())
    return (numericvalue() > o.numericvalue());
  
  assert(0); /* Unsupported comparison */
  exit(-1);
  return true;
}



template <class T>
Typeless& PolymorphBase<T>::set(const Typeless&   o)
{
  const self* oself = dynamic_cast<const self*>(&o);
  if (oself) p = *(oself->p);
  else { assert(0); } // Unsupported assignment; should be an exception instead
  
  return *this;
}



template <class T>
class Polymorph : public PolymorphBase<T> {
public:
  typedef T value_type;
  typedef  Polymorph<value_type> self;
  virtual ~Polymorph() { }
  Polymorph(const value_type  val) : PolymorphBase<value_type>(val) {  };
  Polymorph(      value_type* ptr) : PolymorphBase<value_type>(ptr) {  };
  virtual Typeless* clone()     const { return new self(*this); };
  virtual Typeless* duplicate() const { return new self(*p);    };  
};


template <class T>
Polymorph<T> make_Polymorph(T* ptr)
{  return Polymorph<T>(ptr);  }



template <class T>
Polymorph<T> allocating_Polymorph(const T& val)
{  return Polymorph<T>(val);  }


#define NumericPolymorph(type)\
template <> class Polymorph<type> : public PolymorphBase<type> {\
public:\
  typedef type value_type;\
  typedef  Polymorph<value_type> self;\
  virtual ~Polymorph() { }\
  Polymorph(value_type  val) : PolymorphBase<value_type>(val) {  };\
  Polymorph(value_type* ptr) : PolymorphBase<value_type>(ptr) {  };\
  virtual Typeless* clone()     const { return new self(*this); };\
  virtual Typeless* duplicate() const { return new self(*p);    };\
  virtual bool  isnumeric() const {  return true;  }\
  virtual Typeless::exprtype numericvalue() const\
    {  return Typeless::exprtype(*p);  }\
  virtual string prettyprint(String::StreamFormat format=String::StreamFormat()) const\
    {  return (*p==Uninitialized ? std::string("Uninitialized") : stringrep(format));  }\
}

NumericPolymorph(int);
NumericPolymorph(double);
NumericPolymorph(Tristate);



template <> class Polymorph<string> : public PolymorphBase<string> {
public:
  typedef string value_type;
  typedef  Polymorph<value_type> self;
  virtual ~Polymorph() { }
  Polymorph(value_type  val) : PolymorphBase<value_type>(val) {  };
  Polymorph(value_type* ptr) : PolymorphBase<value_type>(ptr) {  };
  virtual Typeless* clone()     const { return new self(*this); };
  virtual Typeless* duplicate() const { return new self(*p);    };
  virtual string prettyprint(String::StreamFormat format=String::StreamFormat()) const\
    {  return ("\"" + stringrep(format) + "\"");  }
};


#endif /* ___POLYMORPH_H___ */

---