FXVariant.h

/********************************************************************************
*                                                                               *
*                          V a r i a n t   T y p e                              *
*                                                                               *
*********************************************************************************
* Copyright (C) 2013,2024 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or modify          *
* it under the terms of the GNU Lesser General Public License as published by   *
* the Free Software Foundation; either version 3 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 Lesser General Public License for more details.                           *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public License      *
* along with this program.  If not, see <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXVARIANT_H
#define FXVARIANT_H

namespace FX {


class FXString;
class FXVariantMap;
class FXVariantArray;


class FXAPI FXVariant {
public:
  enum Type {
    NullType=0,         // Simple types
    BoolType,
    CharType,
    IntType,
    UIntType,
    LongType,
    ULongType,
    FloatType,
    DoubleType,
    PointerType,
    StringType,         // Complex types
    ArrayType,
    MapType
    };
private:
  union Value {
    FXlong   i;         // Signed integral types
    FXulong  u;         // Unsigned integral types
    FXdouble d;         // Floating point types
    FXchar*  s;         // Character string
    FXptr    p;         // Pointer types
    };
private:
  Value      value;     // Current value
  Type       type;      // Type of value
private:
  void init(Type t);
public:

  FXVariant();

  FXVariant(const FXVariant& other);

  explicit FXVariant(FXbool val);

  explicit FXVariant(FXchar val);

  explicit FXVariant(FXint val);

  explicit FXVariant(FXuint val);

  explicit FXVariant(FXlong val);

  explicit FXVariant(FXulong val);

  explicit FXVariant(FXfloat val);

  explicit FXVariant(FXdouble val);

  explicit FXVariant(FXptr val);

  explicit FXVariant(const FXchar *val);

  explicit FXVariant(const FXString& val);

  void setType(Type t);

  Type getType() const { return type; }

  FXival no() const;

  FXbool no(FXival n);

  FXbool isNull() const { return type==NullType; }

  FXbool isBool() const { return type==BoolType; }

  FXbool isChar() const { return type==CharType; }

  FXbool isInt() const { return type==IntType; }

  FXbool isUInt() const { return type==UIntType; }

  FXbool isLong() const { return type==LongType; }

  FXbool isULong() const { return type==ULongType; }

  FXbool isFloat() const { return type==FloatType; }

  FXbool isDouble() const { return type==DoubleType; }

  FXbool isInteger() const { return BoolType<=type && type<=ULongType; }

  FXbool isReal() const { return FloatType<=type && type<=DoubleType; }

  FXbool isNumber() const { return BoolType<=type && type<=DoubleType; }

  FXbool isPtr() const { return type==PointerType; }

  FXbool isString() const { return type==StringType; }

  FXbool isArray() const { return type==ArrayType; }

  FXbool isMap() const { return type==MapType; }

  FXbool toBool() const;

  FXptr toPtr() const;

  FXint toInt(FXbool* ok=nullptr) const;

  FXuint toUInt(FXbool* ok=nullptr) const;

  FXlong toLong(FXbool* ok=nullptr) const;

  FXulong toULong(FXbool* ok=nullptr) const;

  FXfloat toFloat(FXbool* ok=nullptr) const;

  FXdouble toDouble(FXbool* ok=nullptr) const;

  const FXchar* toChars() const;

  FXString toString(FXbool* ok=nullptr) const;

  operator FXbool() const { return toBool(); }

  operator FXptr() const { return toPtr(); }

  operator FXchar() const { return (FXchar)toInt(); }

  operator FXuchar() const { return (FXuchar)toUInt(); }

  operator FXshort() const { return (FXshort)toInt(); }

  operator FXushort() const { return (FXushort)toUInt(); }

  operator FXint() const { return toInt(); }

  operator FXuint() const { return toUInt(); }

  operator FXlong() const { return toLong(); }

  operator FXulong() const { return toULong(); }

  operator FXfloat() const { return toFloat(); }

  operator FXdouble() const { return toDouble(); }

  operator FXString() const { return toString(); }

  FXVariant& operator=(FXbool val);

  FXVariant& operator=(FXchar val);

  FXVariant& operator=(FXint val);

  FXVariant& operator=(FXuint val);

  FXVariant& operator=(FXlong val);

  FXVariant& operator=(FXulong val);

  FXVariant& operator=(FXfloat val);

  FXVariant& operator=(FXdouble val);

  FXVariant& operator=(FXptr val);

  FXVariant& operator=(const FXchar* val);

  FXVariant& operator=(const FXString& val);

  FXVariant& operator=(const FXVariant& val);

  FXVariant& assign(const FXVariant& other);

  FXVariant& adopt(FXVariant& other);

  FXVariant& at(const FXchar* key);

  const FXVariant& at(const FXchar* key) const;

  FXVariant& operator[](const FXchar* key){ return at(key); }

  const FXVariant& operator[](const FXchar* key) const { return at(key); }

  FXVariant& at(const FXString& key);

  const FXVariant& at(const FXString& key) const;

  FXVariant& operator[](const FXString& key){ return at(key); }

  const FXVariant& operator[](const FXString& key) const { return at(key); }

  FXVariant& at(FXival idx);

  const FXVariant& at(FXival idx) const;

  FXVariant& operator[](FXint idx){ return at(idx); }
  const FXVariant& operator[](FXint idx) const { return at(idx); }

  FXVariant& operator[](FXival idx){ return at(idx); }
  const FXVariant& operator[](FXival idx) const { return at(idx); }

  FXbool has(const FXchar* key) const;

  FXbool has(const FXString& key) const { return has(key.text()); }

  FXptr& asPtr(){ return value.p; }

  const FXptr& asPtr() const { return value.p; }

  FXlong& asLong(){ return value.i; }

  const FXlong& asLong() const { return value.i; }

  FXulong& asULong(){ return value.u; }

  const FXulong& asULong() const { return value.u; }

  FXdouble& asDouble(){ return value.d; }

  const FXdouble& asDouble() const { return value.d; }

  const FXchar* asChars() const { return value.s; }

  FXString& asString(){ return *reinterpret_cast<FXString*>(&value.p); }

  const FXString& asString() const { return *reinterpret_cast<const FXString*>(&value.p); }

  FXVariantArray& asArray(){ return *reinterpret_cast<FXVariantArray*>(&value.p); }

  const FXVariantArray& asArray() const { return *reinterpret_cast<const FXVariantArray*>(&value.p); }

  FXVariantMap& asMap(){ return *reinterpret_cast<FXVariantMap*>(&value.p); }

  const FXVariantMap& asMap() const { return *reinterpret_cast<const FXVariantMap*>(&value.p); }

  FXbool remove(const FXchar* key);

  FXbool remove(const FXString& key){ return remove(key.text()); }

  FXbool erase(FXival idx);

  FXbool clear();

  static const FXVariant null;

 ~FXVariant();
  };

}

#endif