var.h

// Copyright (c) 2014 Yasser Asmi
// Released under the MIT License (http://opensource.org/licenses/MIT)

#ifndef _VAR_H
#define _VAR_H

#include "util.h"
#include "arr.h"
#include "str.h"
#include <math.h>

#define VNULL Variant::vNull
#define VEMPTY Variant::vEmpty

#define VAR_PATH_DELIM     "."

namespace jvar
{

class VarFuncObj;

class Variant
{
public:
    typedef int (*Compare)(const Variant*, const Variant*);

    enum Type
    {
        V_EMPTY,
        V_NULL,
        V_INT,
        V_BOOL,
        V_DOUBLE,
        V_STRING,
        V_ARRAY,
        V_OBJECT,
        V_FUNCTION,
        V_POINTER
    };

public:

    inline Variant()
    {
        mData.type = V_EMPTY;
        mData.flags = 0;
    }

    inline Variant(longint i)
    {
        mData.type = V_INT;
        mData.intData = i;
    }

    inline Variant(int i)
    {
        mData.type = V_INT;
        mData.intData = (longint)i;
    }

    inline Variant(double d)
    {
        mData.type = V_DOUBLE;
        mData.dblData = d;
    }

    inline Variant(std::string s)
    {
        mData.type = V_STRING;

        // Inplace new a std::string object with the source string passed to
        // the constructor.

        new (&mData.strMemData) std::string(s);
    }

    inline Variant(const char* s)
    {
        mData.type = V_STRING;

        // Inplace new a std::string object with the source string passed to
        // the constructor.

        new (&mData.strMemData) std::string(s);
    }

    inline Variant(Variant const& src)
    {
        mData.type = V_EMPTY;
        *this = src;
    }

    inline ~Variant()
    {
        (void)deleteData();
    }

    inline Variant& operator=(const Variant& src)
    {
        copyFrom(&src);
        return *this;
    }

    inline Variant& operator=(const Variant* src)
    {
        copyFrom(src);
        return *this;
    }

    inline Variant& operator=(const char* src)
    {
        assignStr(src);
        return *this;
    }

    inline Variant& operator=(const std::string& src)
    {
        assignStr(src);
        return *this;
    }

    inline Variant& operator=(bool src)
    {
        assignBool(src);
        return *this;
    }

    inline Variant& operator=(longint src)
    {
        assignInt(src);
        return *this;
    }

    inline Variant& operator=(int src)
    {
        assignInt((longint)src);
        return *this;
    }

    inline Variant& operator=(double src)
    {
        assignDbl(src);
        return *this;
    }

    inline Variant& operator=(float src)
    {
        assignDbl((double)src);
        return *this;
    }

    inline Variant& operator+=(const Variant& rhs)
    {
        internalAdd(*this, rhs);
        return *this;
    }

    inline Variant& operator+=(longint rhs)
    {
        Variant r(rhs);
        internalAdd(*this, r);
        return *this;
    }

    inline Variant& operator+=(int rhs)
    {
        Variant r((longint)rhs);
        internalAdd(*this, r);
        return *this;
    }

    inline Variant& operator+=(const char* rhs)
    {
        Variant r(rhs);
        internalAdd(*this, r);
        return *this;
    }

    inline Variant& operator+=(const std::string& rhs)
    {
        Variant r(rhs);
        internalAdd(*this, r);
        return *this;
    }

    inline Variant& operator+=(double rhs)
    {
        Variant r(rhs);
        internalAdd(*this, r);
        return *this;
    }

    inline Variant& operator++()
    {
        Variant r(1);
        internalAdd(*this, r);
        return *this;
    }

    inline Variant operator++(int)
    {
        Variant r(1);
        internalAdd(*this, r);
        return *this;
    }

    inline longint toInt() const
    {
        return makeInt();
    }

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

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

    inline operator longint() const
    {
        return makeInt();
    }

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

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

    inline operator const char*()
    {
        return c_str();
    }

    inline const char* c_str() const
    {
        if (mData.type == V_STRING)
        {
            return mData.strData()->c_str();
        }
        return NULL;
    }

    std::string& s();

    std::string toString() const;

    std::string toFixed(int digs = 0) const;

    std::string toJsonString() const;

    bool parseJson(const char* jsontxt);

    void format(const char* fmt, ...);

    inline Type type() const
    {
        return (Type)(mData.type);
    }

    const char* typeName() const;

    inline bool isNull() const
    {
        return (mData.type == V_NULL);
    }
    inline bool isEmpty() const
    {
        return (mData.type == V_EMPTY);
    }
    inline bool isObject() const
    {
        return (mData.type == V_OBJECT);
    }
    inline bool isArray() const
    {
        return (mData.type == V_ARRAY);
    }
    inline bool isPointer() const
    {
        return (mData.type == V_POINTER);
    }
    inline bool isNaN()
    {
        if (mData.type == V_DOUBLE)
        {
            return isnan(mData.dblData);
        }
        else if (mData.type == V_INT)
        {
            return false;
        }
        return true;
    }

    int length() const;

    Variant& operator[](int i);

    const Variant& operator[](int i) const;

    Variant& operator[](const char* key);

    const Variant& operator[](const char* key) const;

    Variant& path(const char* pathkey);

    inline Variant& path(const std::string& pathkey)
    {
        return path(pathkey.c_str());
    }

    void createArray(const char* initvalue = NULL);

    Variant* append(const Variant& elem = VEMPTY);

    inline void push(const Variant& elem)
    {
        (void)append(elem);
    }

    Variant pop();

    Variant shift();

    void sort(Compare comp);

    void createObject(const char* initvalue = NULL);

    Variant& addProperty(const char* key, const Variant& value = vEmpty);

    bool hasProperty(const char* key);

    const char* getKey(int n);

    void createFunction(Variant (*func)(Variant& env, Variant& arg));

    bool addEnv(const char* varname, const Variant& value = vEmpty);
    Variant operator() ();
    Variant operator() (const Variant& value1);
    Variant operator() (const Variant& value1, const Variant& value2);
    Variant operator() (const Variant& value1, const Variant& value2, const Variant& value3);
    Variant operator() (const Variant& value1, const Variant& value2, const Variant& value3, const Variant& value4);

    inline bool forEach(Iter<Variant>& iter)
    {
        if (mData.type == V_ARRAY)
        {
            return mData.arrayData->forEach(iter);
        }
        else if (mData.type == V_OBJECT)
        {
            return mData.objectData->forEach(iter);
        }
        return false;
    }

    inline void clear()
    {
        (void)deleteData();
    }

    inline void setModified()
    {
        setFlag(mData.flags, VF_MODIFIED);
    }

    inline void clearModified()
    {
        clearFlag(mData.flags, VF_MODIFIED);
    }

    inline bool isModified()
    {
        return isFlagSet(mData.flags, VF_MODIFIED);
    }

private:

    enum Flags
    {
        VF_MODIFIED = 0x1
    };

    #pragma pack(push, 4)
    struct VarData
    {
        ushortint type;
        shortint flags;
        union
        {
            longint intData;
            double dblData;
            bool boolData;
            char strMemData[sizeof(std::string)];
            ObjArray<Variant>* arrayData;
            PropArray<Variant>* objectData;
            VarFuncObj* funcData;
            Variant* vptrData;
        };

        std::string* strData() const
        {
            return (std::string*)&strMemData;
        }
    };
    #pragma pack(pop)

    VarData mData;

private:

    bool deleteData();
    void copyFrom(const Variant* src);

    void assignInt(longint src);
    void assignDbl(double src);
    void assignBool(bool src);
    void assignStr(const char* src);
    void assignStr(const std::string& src);

    longint makeInt() const;
    double makeDbl() const;
    inline bool makeBool() const
    {
        return makeInt() == 0 ? false : true;
    }
    void makeString(std::string& s, int level, bool json);

    void jsonifyStr(std::string& s);
    inline void appendQuote(std::string& s, Type type)
    {
        if (type == V_STRING)
        {
            s += '"';
        }
    }
    inline void appendNewline(std::string& s, int level, bool json)
    {
        if (json)
        {
            s += '\n';
            s += std::string(level, '\t');
        }
    }

    static const KeywordArray::Entry sTypeNames[];

public:
    static Variant vEmpty;
    static Variant vNull;

public:
    Variant(Type type)
    {
        mData.type = type;
    }

    void internalAdd(const Variant& lhs, const Variant& rhs);
    void internalSetPtr(const Variant* v);

};

class VarFuncObj
{
public:
    VarFuncObj() :
        mFunc(NULL)
    {
    }

    Variant mEnv;
    Variant (*mFunc)(Variant& env, Variant& arg);
};
inline Variant operator+(const Variant& lhs, const Variant& rhs)
{
    Variant res;
    res.internalAdd(lhs, rhs);
    return res;
}

inline Variant operator+(const Variant& lhs, const char* rhs)
{
    Variant res;
    Variant r(rhs);
    res.internalAdd(lhs, r);
    return res;
}

inline Variant operator+(const char* lhs, const Variant& rhs)
{
    Variant res;
    Variant l(lhs);
    res.internalAdd(l, rhs);
    return res;
}

inline Variant operator+(const std::string& lhs, const Variant& rhs)
{
    Variant res;
    Variant l(lhs);
    res.internalAdd(l, rhs);
    return res;
}

inline Variant operator+(const Variant& lhs, const std::string& rhs)
{
    Variant res;
    Variant r(rhs);
    res.internalAdd(lhs, r);
    return res;
}

inline Variant operator+(const Variant& lhs, longint rhs)
{
    Variant res;
    Variant r(rhs);
    res.internalAdd(lhs, r);
    return res;
}

inline Variant operator+(const Variant& lhs, int rhs)
{
    return operator+(lhs, (longint)rhs);
}

inline Variant operator+(const Variant& lhs, double rhs)
{
    Variant res;
    Variant r(rhs);
    res.internalAdd(lhs, r);
    return res;
}

inline Variant operator+(double lhs, const Variant& rhs)
{
    Variant res;
    Variant l(lhs);
    res.internalAdd(l, rhs);
    return res;
}

} // jvar

#endif // _VAR_H