Variant.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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,
    TypeChar16,
    TypeInt,
    TypeUInt,
    TypeFloat,
    TypeDouble,
    TypeInt64,
    TypeUInt64,
    TypeString,
    TypeBlob,
    TypeOpaque,
    TypeList,
    TypeMap
  };

  Variant();

  Variant(const Variant& other);

  explicit Variant(bool val);

  explicit Variant(char val);

  explicit Variant(char16_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 char* val);

  explicit Variant(const char16_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 isChar16() const
  { return(_type == TypeChar16); }

  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 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;

  char16_t toChar16() 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;

  Blob toBlob() const;

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

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

  inline operator char16_t() const
  { return(toChar16()); }

  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 Blob() const
  { return(toBlob()); }

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

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

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

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

  uint_t length() const;

  void clear();

  void setNull();

  Variant& operator=(bool val);

  Variant& operator=(char val);

  Variant& operator=(char16_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);

  inline Variant& operator=(const char* val)
  { return(operator=(String(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);

  const Variant &get(int index) const;

  inline const Variant &operator[](int index) const
  { 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;
    char16_t char16Val;
    int32_t intVal;
    uint32_t uintVal;
    float floatVal;
    double doubleVal;
    int64_t int64Val;
    uint64_t uint64Val;
    String* stringVal;
    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