tb_value.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_VALUE_H
#define TB_VALUE_H

#include "tb_core.h"
#include "tb_list.h"
#include "tb_str.h"

namespace tb {

class TBValue;
class TBTypedObject;

bool is_start_of_number(const char *str);

bool contains_non_trailing_space(const char *str);

bool is_number_only(const char *str);

bool is_number_float(const char *str);

class TBValueArray
{
public:
    TBValueArray();
    ~TBValueArray();
    TBValue *AddValue();
    TBValue *GetValue(int index);
    bool Equals(const TBValueArray & rhs) const;
    static TBValueArray *Clone(TBValueArray *source);
    int GetLength() const { return m_list.GetNumItems(); }
private:
    TBListAutoDeleteOf<TBValue> m_list;
};

class TBValue
{
public:
    enum TYPE {
        TYPE_NULL,
        TYPE_STRING,
        TYPE_FLOAT,
        TYPE_INT,
        TYPE_OBJECT,
        TYPE_ARRAY
    };

    enum SET_MODE {
        SET_NEW_COPY,           
        SET_TAKE_OWNERSHIP,     
        SET_AS_STATIC           
    };

    TBValue();
    TBValue(TBValue && val) = default;
    TBValue(const TBValue &value);
    TBValue(TYPE type);

    TBValue(int value) : TBValue((long)value) {}
    TBValue(long value);
    TBValue(double value);
    TBValue(const char *value, SET_MODE set = SET_NEW_COPY);
    TBValue(const TBStr & str) : TBValue((const char *)str) {}
    TBValue(TBStr && str);
    TBValue(TBTypedObject *object, SET_MODE set = SET_TAKE_OWNERSHIP);

    ~TBValue();

    void TakeOver(TBValue &source_value);

    void Copy(const TBValue &source_value);

    void SetNull();
    void SetInt(long val);
    void SetFloat(double val);

    void SetString(const char *val, SET_MODE set);

    void SetString(const TBStr & str) { SetString(str.CStr(), SET_NEW_COPY); }

    void SetObject(TBTypedObject *object, SET_MODE set);

    void SetArray(TBValueArray *arr, SET_MODE set);

    void SetFromStringAuto(const char *str, SET_MODE set);

    long GetInt() const;
    double GetFloat() const;
    TBStr GetString() const;
    TBTypedObject *GetObject() const { return IsObject() ? val_obj : nullptr; }
    TBValueArray *GetArray() const { return IsArray() ? val_arr : nullptr; }

    bool Equals(int value) const { return Equals((long)value); }
    bool Equals(long value) const;
    bool Equals(double value) const;
    bool Equals(const char * value) const;
    bool Equals(const TBStr & value) const { return Equals(value.CStr()); }
    bool Equals(const TBValue & value) const;

    TYPE GetType() const { return (TYPE) m_packed.type; }
    bool IsString() const { return m_packed.type == TYPE_STRING; }
    bool IsFloat() const { return m_packed.type == TYPE_FLOAT; }
    bool IsInt() const { return m_packed.type == TYPE_INT; }
    bool IsObject() const { return m_packed.type == TYPE_OBJECT; }
    bool IsArray() const { return m_packed.type == TYPE_ARRAY; }
    int GetArrayLength() const { return IsArray() ? val_arr->GetLength() : 0; }

    const TBValue& operator = (const TBValue &val) { Copy(val); return *this; }
    TBValue & operator = (TBValue && val) = default;
    /*{
        std::swap(val_float, val.val_float);
        std::swap(m_packed_init, val.m_packed_init);
        return *this;
        }*/

private:
    union {
        double val_float;
        long val_int;
        char *val_str;
        TBTypedObject *val_obj;
        TBValueArray *val_arr;
    };
    union {
        struct {
            uint32_t type : 8;
            uint32_t allocated : 1;
        } m_packed;
        uint32_t m_packed_init;
    };
};

} // namespace tb

#endif // TB_VALUE_H