Variant.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, 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 GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_Variant_hxx
#define __ccxx_Variant_hxx

#include <commonc++/Common.h++>
#include <commonc++/Blob.h++>
#include <commonc++/String.h++>

#include <sys/types.h>
#include <iostream>

namespace ccxx {

class COMMONCPP_API Variant
{
  public:

  enum Type { TypeNull = 0, TypeBool, TypeChar, TypeWChar, TypeInt, TypeUInt,
              TypeFloat, TypeDouble, TypeInt64, TypeUInt64, TypeString,
              TypeWString, TypeBlob, TypeOpaque, TypeList, TypeMap };

  Variant();

  Variant(const Variant &other);

  explicit Variant(bool val);

  explicit Variant(char val);

  explicit Variant(wchar_t val);

  explicit Variant(int32_t val);

  explicit Variant(uint32_t val);

  explicit Variant(float val);

  explicit Variant(const double &val);

  explicit Variant(const int64_t &val);

  explicit Variant(const uint64_t &val);

  explicit Variant(const String &val);

  explicit Variant(const WString &val);

  explicit Variant(const char *val);

  explicit Variant(const wchar_t *val);

  explicit Variant(const Blob &val);

  explicit Variant(void *val);

  virtual ~Variant();

  inline Type getType() const
  { return(_type); }

  void setType(Type type);

  inline bool isNull() const
  { return(_type == TypeNull); }

  inline bool isBool() const
  { return(_type == TypeBool); }

  inline bool isChar() const
  { return(_type == TypeChar); }

  inline bool isWChar() const
  { return(_type == TypeWChar); }

  inline bool isInt() const
  { return(_type == TypeInt); }

  inline bool isUInt() const
  { return(_type == TypeUInt); }

  inline bool isFloat() const
  { return(_type == TypeFloat); }

  inline bool isDouble() const
  { return(_type == TypeDouble); }

  inline bool isInt64() const
  { return(_type == TypeInt64); }

  inline bool isUInt64() const
  { return(_type == TypeUInt64); }

  inline bool isString() const
  { return(_type == TypeString); }

  inline bool isWString() const
  { return(_type == TypeWString); }

  inline bool isBlob() const
  { return(_type == TypeBlob); }

  inline bool isOpaque() const
  { return(_type == TypeOpaque); }

  inline bool isList() const
  { return(_type == TypeList); }

  inline bool isMap() const
  { return(_type == TypeMap); }

  bool toBool() const;

  char toChar() const;

  wchar_t toWChar() const;

  int32_t toInt() const;

  uint32_t toUInt() const;

  float toFloat() const;

  double toDouble() const;

  int64_t toInt64() const;

  uint64_t toUInt64() const;

  void * toOpaque() const;

  String toString() const;

  WString toWString() const;

  Blob toBlob() const;

  inline operator bool() const
  { return(toBool()); }

  inline operator char() const
  { return(toChar()); }

  inline operator wchar_t() const
  { return(toWChar()); }

  inline operator int32_t() const
  { return(toInt()); }

  inline operator uint32_t() const
  { return(toUInt()); }

  inline operator float() const
  { return(toFloat()); }

  inline operator double() const
  { return(toDouble()); }

  inline operator String() const
  { return(toString()); }

  inline operator WString() const
  { return(toWString()); }

  inline operator Blob() const
  { return(toBlob()); }

  inline operator int64_t() const
  { return(toInt64()); }

  inline operator uint64_t() const
  { return(toUInt64()); }

  inline operator const void *() const throw()
  { return(isNull() ? NULL : this); }

  inline bool operator!() const throw()
  { return(isNull()); }

  size_t length() const;

  void clear();

  void setNull();

  Variant& operator=(bool val);

  Variant& operator=(char val);

  Variant& operator=(wchar_t val);

  Variant& operator=(int32_t val);

  Variant& operator=(uint32_t val);

  Variant& operator=(float val);

  Variant& operator=(const double &val);

  Variant& operator=(const int64_t &val);

  Variant& operator=(const uint64_t &val);

  Variant& operator=(const String &val);

  Variant& operator=(const WString &val);

  inline Variant& operator=(const char *val)
  { return(operator=(String(val))); }

  inline Variant& operator=(const wchar_t *val)
  { return(operator=(WString(val))); }

  Variant& operator=(const Blob &val);

  Variant& operator=(void *val);

  Variant& operator=(const Variant& other);

  Variant& operator[](const String &name);

  inline Variant& operator[](const char *name)
  { return(operator[](String(name))); }

  const Variant &get(const String &name) const;

  inline const Variant &operator[](const String &name) const
  { return(get(name)); }

  inline const Variant &operator[](const char *name) const
  { return(get(String(name))); }

  Variant& operator[](int index) throw(OutOfBoundsException);

  const Variant &get(int index) const throw(OutOfBoundsException);

  inline const Variant &operator[](int index) const
    throw(OutOfBoundsException)
  { return(get(index)); }

  bool getKeys(StringVec &vec) const;

  bool hasKey(const String &key) const;

  bool operator==(const Variant &other) const;

  inline bool operator!=(const Variant &other) const
  { return(! operator==(other)); }

  void write(std::ostream &stream) const;

  static const Variant null;

  private:

  class VariantList; // fwd decl
  class VariantMap; // fwd decl

  void _copy(const Variant& other);
  void _deleteValue();
  void _initValue();

  Type _type;

  union {
    bool boolVal;
    char charVal;
    wchar_t wcharVal;
    int32_t intVal;
    uint32_t uintVal;
    float floatVal;
    double doubleVal;
    int64_t int64Val;
    uint64_t uint64Val;
    String *stringVal;
    WString *wstringVal;
    Blob *blobVal;
    VariantList *listVal;
    VariantMap *mapVal;
    void *opaqueVal;
  } _value;

};

inline std::ostream& operator<<(std::ostream& stream, const Variant& v) {
  v.write(stream);
  return(stream);
}

}; // namespace ccxx

#endif // __ccxx_Variant_hxx

/* end of header file */