Element.h

// This file may be redistributed and modified only under the terms of
// the GNU Lesser General Public License (See COPYING for details).
// Copyright (C) 2000-2001 Stefanus Du Toit, Karsten-O. Laux and Al Riddoch
 
// $Id$
 
#ifndef ATLAS_MESSAGE_ELEMENT_H
#define ATLAS_MESSAGE_ELEMENT_H
 
#include <Atlas/Exception.h>
#include <Atlas/float.h>
 
#include <string>
#include <map>
#include <vector>
 
namespace Atlas { namespace Message {
 
class WrongTypeException : public Atlas::Exception
{
  public:
    WrongTypeException() : Atlas::Exception("Wrong Message::Element type") { }
};
 
class Element;
 
typedef long IntType;
typedef double FloatType;
typedef void * PtrType;
typedef std::string StringType;
typedef std::map<std::string, Element> MapType;
typedef std::vector<Element> ListType;
 
class Element
{
public:
    enum Type {
        TYPE_NONE,
        TYPE_INT,
        TYPE_FLOAT,
        TYPE_PTR,
        TYPE_STRING,
        TYPE_MAP,
        TYPE_LIST
    };
 
private:
    // These are now legacy typedefs. New code should use the
    // Atlas::Message::*Type versions.
    typedef Atlas::Message::IntType IntType;
    typedef Atlas::Message::FloatType FloatType;
    typedef Atlas::Message::PtrType PtrType;
    typedef Atlas::Message::StringType StringType;
    typedef Atlas::Message::MapType MapType;
    typedef Atlas::Message::ListType ListType;
 
    void clear(Type new_type = TYPE_NONE);
 
public:
    Element()
      : t(TYPE_NONE)
    {
    }
 
    ~Element()
    {
        clear();
    }
 
    Element(const Element& obj);
 
    Element(int v)
      : t(TYPE_INT), i(v)
    {
    }
 
    Element(bool v)
      : t(TYPE_INT), i(v)
    {
    }
 
    Element(IntType v)
      : t(TYPE_INT), i(v)
    {
    }
 
    Element(float v)
      : t(TYPE_FLOAT), f(v)
    {
    }   
 
    Element(FloatType v)
      : t(TYPE_FLOAT), f(v)
    {
    }
 
    Element(PtrType v)
      : t(TYPE_PTR), p(v)
    {
    }
 
    Element(const char* v)
      : t(TYPE_STRING)
    {
      if(v)
        s = new DataType<StringType>(v);
      else
        s = new DataType<StringType>();
    }
 
    Element(const StringType& v)
      : t(TYPE_STRING)
    {
      s = new DataType<StringType>(v);
    }
    Element(const MapType& v)
      : t(TYPE_MAP)
    {
      m = new DataType<MapType>(v);
    }
    Element(const ListType& v)
      : t(TYPE_LIST)
    {
      l = new DataType<ListType>(v);
    }
 
    Element& operator=(const Element& obj);
 
    Element& operator=(int v) 
    {
      if (TYPE_INT != t)
      {
        clear(TYPE_INT);
      }
      i = v;
      return *this;
    }
 
    Element& operator=(bool v) 
    {
      if (TYPE_INT != t)
      {
        clear(TYPE_INT);
      }
      i = v;
      return *this;
    }
 
    Element& operator=(IntType v) 
    {
      if (TYPE_INT != t)
      {
        clear(TYPE_INT);
      }
      i = v;
      return *this;
    }
 
    Element& operator=(float v) 
    {
      if (TYPE_FLOAT != t)
      {
        clear(TYPE_FLOAT);
      }
      f = v;
      return *this;
    }
 
    Element& operator=(FloatType v) 
    {
      if (TYPE_FLOAT != t)
      {
        clear(TYPE_FLOAT);
      }
      f = v;
      return *this;
    }
 
    Element& operator=(PtrType v) 
    {
      if (TYPE_PTR != t)
      {
        clear(TYPE_PTR);
      }
      p = v;
      return *this;
    }
 
    Element& operator=(const char * v) 
    {
      if (TYPE_STRING != t || !s->unique())
      {
        clear(TYPE_STRING);
        s = new DataType<StringType>(v);
      } else {
        *s = StringType(v);
      }
      return *this;
    }
 
    Element& operator=(const StringType & v) 
    {
      if (TYPE_STRING != t || !s->unique())
      {
        clear(TYPE_STRING);
        s = new DataType<StringType>(v);
      } else {
        *s = v;
      }
      return *this;
    }
 
    Element& operator=(const MapType & v) 
    {
      if (TYPE_MAP != t || !m->unique())
      {
        clear(TYPE_MAP);
        m = new DataType<MapType>(v);
      } else {
        *m = v;
      }
      return *this;
    }
 
    Element& operator=(const ListType & v) 
    {
      if (TYPE_LIST != t || !l->unique())
      {
        clear(TYPE_LIST);
        l = new DataType<ListType>(v);
      } else {
        *l = v;
      }
      return *this;
    }
 
    bool operator==(const Element& o) const;
 
#if defined(__GNUC__) && __GNUC__ < 3
    bool operator!=(const Element& o) const
    {
        return !(*this == o);
    }
#endif // defined(__GNUC__) && __GNUC__ < 3
    
    template<class C>
    bool operator!=(C c) const
    {
        return !(*this == c);
    }
 
    bool operator==(IntType v) const
    {
      return (t == TYPE_INT && i == v);
    }
 
    bool operator==(FloatType v) const
    {
      return t == TYPE_FLOAT && Equal(f, v);
    }
 
    bool operator==(PtrType v) const
    {
      return t == TYPE_PTR && p == v;
    }
 
    bool operator==(const char * v) const
    {
      if(t == TYPE_STRING)
        return (*s == v);
      return false;
    }
 
    bool operator==(const StringType& v) const
    {
      if(t == TYPE_STRING)
        return (*s == v);
      return false;
    }
 
    bool operator==(const MapType& v) const
    {
      if(t == TYPE_MAP)
        return (*m == v);
      return false;
    }
 
    bool operator==(const ListType& v) const
    {
      if (t == TYPE_LIST)
        return (*l == v);
      return false;
    }
 
    Type getType() const { return t; }
    bool isNone() const { return (t == TYPE_NONE); }
    bool isInt() const { return (t == TYPE_INT); }
    bool isFloat() const { return (t == TYPE_FLOAT); }
    bool isPtr() const { return (t == TYPE_PTR); }
    bool isNum() const { return ((t == TYPE_FLOAT) || (t == TYPE_INT)); }
    bool isString() const { return (t == TYPE_STRING); }
    bool isMap() const { return (t == TYPE_MAP); }
    bool isList() const { return (t == TYPE_LIST); }
 
    IntType asInt() const
    {
        if (t == TYPE_INT) return i;
        throw WrongTypeException();
    }
    IntType Int() const
    {
        return i;
    }
    FloatType asFloat() const
    {
        if (t == TYPE_FLOAT) return f;
        throw WrongTypeException();
    }
    FloatType Float() const
    {
        return f;
    }
    PtrType asPtr() const
    {
        if (t == TYPE_PTR) return p;
        throw WrongTypeException();
    }
    PtrType Ptr() const
    {
        return p;
    }
    FloatType asNum() const
    {
        if (t == TYPE_FLOAT) return f;
        if (t == TYPE_INT) return FloatType(i);
        throw WrongTypeException();
    }
    const std::string& asString() const
    {
        if (t == TYPE_STRING) return *s;
        throw WrongTypeException();
    }
    std::string& asString()
    {
        if (t == TYPE_STRING) return *(s = s->makeUnique());
        throw WrongTypeException();
    }
    const StringType& String() const
    {
        return *s;
    }
    StringType& String()
    {
        return *(s = s->makeUnique());
    }
    const MapType& asMap() const
    {
        if (t == TYPE_MAP) return *m;
        throw WrongTypeException();
    }
    MapType& asMap()
    {
        if (t == TYPE_MAP) return *(m = m->makeUnique());
        throw WrongTypeException();
    }
    const MapType& Map() const
    {
        return *m;
    }
    MapType& Map()
    {
        return *(m = m->makeUnique());
    }
    const ListType& asList() const
    {
        if (t == TYPE_LIST) return *l;
        throw WrongTypeException();
    }
    ListType& asList()
    {
        if (t == TYPE_LIST) return *(l = l->makeUnique());
        throw WrongTypeException();
    }
    const ListType& List() const
    {
        return *l;
    }
    ListType& List()
    {
        return *(l = l->makeUnique());
    }
 
    static const char * typeName(Type);
 
protected:
 
    template<class C>
    class DataType
    {
    public:
        DataType() : _refcount(1), _data(0) {}
        DataType(const C& c) : _refcount(1), _data(c) {}
 
        DataType& operator=(const C& c) {_data = c; return *this;}
 
        bool operator==(const C& c) const {return _data == c;}
 
        void ref() {++_refcount;}
        void unref() {if(--_refcount == 0) delete this;}
 
        bool unique() const {return _refcount == 1;}
        DataType* makeUnique()
        {
           if(unique())
               return this;
           unref(); // _refcount > 1, so this is fine
           return new DataType(_data);
        }
 
        operator C&() {return _data;}
//        operator const C&() const {return _data;}
 
    private:
        DataType(const DataType&); // unimplemented
        DataType& operator=(const DataType&); // unimplemented
 
        unsigned long _refcount;
        C _data;
    };
 
    Type t;
    union {
      IntType i;
      FloatType f;
      void* p;
      DataType<StringType>* s;
      DataType<MapType>* m;
      DataType<ListType>* l;
    };
};
 
} } // namespace Atlas::Message
 
 
#endif // ATLAS_MESSAGE_ELEMENT_H