CUJsonValue.h

//
//  CUJsonValue.h
//  Cornell University Game Library (CUGL)
//
//  This module a modern C++ alternative to the cJSON interface for reading
//  JSON files.  In particular, this gives us better type-checking and memory
//  management.  With that said, it still uses cJSON as the underlying parsing
//  engine.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 11/28/16
//
#ifndef __CU_JSON_VALUE_H__
#define __CU_JSON_VALUE_H__
#include <cJSON/cJSON.h>
#include <vector>
#include <string>

namespace cugl {

class JsonValue {
public:
    enum class Type : int {
        NullType   = 0,
        BoolType   = 1,
        NumberType = 2,
        StringType = 3,
        ArrayType  = 4,
        ObjectType = 5
    };

private:
    Type _type;
    
    JsonValue* _parent;
    std::string _key;
    
    std::string _stringValue;
    long   _longValue;
    double _doubleValue;
    
    std::vector<std::shared_ptr<JsonValue>> _children;

#pragma mark -
#pragma mark cJSON Conversions

    static std::shared_ptr<JsonValue> toJsonValue(const cJSON* node);

    static void toJsonValue(JsonValue* value, const cJSON* node);
    
    static cJSON* toCJSON(const JsonValue* value);
    
#pragma mark -
#pragma mark Constructors
public:
    JsonValue();
    
    ~JsonValue();
    
    bool init(Type type);

    bool init(const std::string& value);

    bool init(const char* value) { return init(std::string(value)); }

    bool init(bool value);

    bool init(long value);

    bool init(double value);

    bool initNull() { return init(Type::NullType); }

    bool initArray() { return init(Type::ArrayType); }

    bool initObject() { return init(Type::ObjectType); }
    
    bool initWithJson(const std::string& json) {
        return initWithJson(json.c_str());
    }
    
    bool initWithJson(const char* json);

    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<JsonValue> alloc(Type type) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->init(type) ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> alloc(const std::string& value) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->init(value) ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> alloc(const char* value) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->init(value) ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> alloc(bool value) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->init(value) ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> alloc(long value) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->init(value) ? result : nullptr);
    }
    
    static std::shared_ptr<JsonValue> alloc(double value) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->init(value) ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> allocNull() {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->initNull() ? result : nullptr);
    }
    
    static std::shared_ptr<JsonValue> allocArray() {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->initArray() ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> allocObject() {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->initObject() ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> allocWithJson(const std::string& json) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->initWithJson(json) ? result : nullptr);
    }

    static std::shared_ptr<JsonValue> allocWithJson(const char* json) {
        std::shared_ptr<JsonValue> result = std::make_shared<JsonValue>();
        return (result->initWithJson(json) ? result : nullptr);
    }

    
#pragma mark -
#pragma mark Type

    Type type() const      { return _type; }

    bool isNull() const     { return _type == Type::NullType; }
    
    bool isNumber() const   { return _type == Type::NumberType; }
    
    bool isBool() const     { return _type == Type::BoolType;   }
    
    bool isString() const   { return _type == Type::StringType; }

    bool isValue() const;

    bool isArray() const    {  return _type == Type::ArrayType; }
    
    bool isObject() const   { return _type == Type::ObjectType; }


#pragma mark -
#pragma mark Value Access

    const std::string asString(const std::string& defaultValue) const {
        return asString(defaultValue.c_str());
    }
    
    const std::string asString(const char* defaultValue="") const;
    
    float asFloat(float defaultValue=0.0f) const;
    
    double asDouble(double defaultValue=0.0) const;
    
    long asLong(long defaultValue=0L) const;
    
    int asInt(int defaultValue=0) const;
    
    bool asBool(bool defaultValue=false) const;
    
    std::vector<std::string> asStringArray(const std::string& defaultValue) const;
    
    std::vector<std::string> asStringArray(const char* defaultValue="") const {
        return asStringArray(std::string(defaultValue));
    }
    
    std::vector<float> asFloatArray(float defaultValue=0.0f) const;
    
    std::vector<double> asDoubleArray(double defaultValue=0.0) const;
    
    std::vector<long> asLongArray(long defaultValue=0L) const;
    
    std::vector<int> asIntArray(int defaultValue=0) const;
    
    std::vector<bool> asBoolArray (bool defaultValue=false);
    
    
#pragma mark -
#pragma mark Value Modification

    void set(const std::string& value);
    
    void set(const char* value) {
        set(std::string(value));
    }
    
    void set(long value);

    void set(double value);
    
    void set(bool value);
    
    void setNull();

    
#pragma mark -
#pragma mark Child Access

    const std::string& key() const;
    
    void setKey(const std::string& key);

    void setKey(const char* key) { setKey(std::string(key)); }

    const int index() const;

    size_t size() const { return _children.size(); }
    
    bool has(const std::string& name) const;
    
    bool has(const char* name) const {
        return has(std::string(name));
    }

    std::shared_ptr<JsonValue> get(int index);
    
    const std::shared_ptr<JsonValue> get(int index) const;
    
    std::shared_ptr<JsonValue> get(const std::string& name);
    
    const std::shared_ptr<JsonValue> get(const std::string& name) const;

    std::shared_ptr<JsonValue> get(const char* name) {
        return get(std::string(name));
    }
    
    const std::shared_ptr<JsonValue> get(const char* name) const {
        return get(std::string(name));
    }
    
    
#pragma mark -
#pragma mark Child Values

    const std::string getString (const std::string& key, const std::string& defaultValue) const;
    
    const std::string getString (const char* key, const char* defaultValue="") const {
        return getString(std::string(key),std::string(defaultValue));
    }
    
    const std::string getString (const std::string& key, const char* defaultValue="") const {
        return getString(key,std::string(defaultValue));
    }
    
    const std::string getString (const char* key, const std::string& defaultValue) const {
        return getString(std::string(key),defaultValue);
    }
    
    float getFloat(const std::string& key, float defaultValue=0.0f) const;
    
    float getFloat(const char* key, float defaultValue=0.0f) const {
        return getFloat(std::string(key),defaultValue);
    }
    
    double getDouble(const std::string& key, double defaultValue=0.0) const;
    
    double getDouble(const char* key, double defaultValue=0.0) const {
        return getDouble(std::string(key),defaultValue);
    }
    
    long getLong(const std::string& key, long defaultValue=0L) const;
    
    long getLong(const char* key, long defaultValue=0L) const {
        return getLong(std::string(key),defaultValue);
    }
    
    int getInt(const std::string& key, int defaultValue=0) const;
    
    int getInt(const char* key, int defaultValue=0) const {
        return getInt(std::string(key),defaultValue);
    }
    
    bool getBool(const std::string& key, bool defaultValue=false) const;

    bool getBool(const char* key, bool defaultValue=false) const {
        return getBool(std::string(key),defaultValue);
    }
    
#pragma mark -
#pragma mark Child Deletion

    std::shared_ptr<JsonValue> removeChild(int index);
    
    std::shared_ptr<JsonValue> removeChild(const std::string& name);
    
    std::shared_ptr<JsonValue> removeChild(const char* name) {
        return removeChild(std::string(name));
    }
    
#pragma mark -
#pragma mark Child Addition

    void appendChild(const std::shared_ptr<JsonValue>& child);
    
    void appendChild(const std::string& key, const std::shared_ptr<JsonValue>& child);

    void appendChild(const char* key, const std::shared_ptr<JsonValue>& child) {
        return appendChild(std::string(key),child);
    }
    
    void insertChild(unsigned int index, const std::shared_ptr<JsonValue>& child);

    void insertChild(unsigned int index, const std::string& key, const std::shared_ptr<JsonValue>& child);

    void insertChild(unsigned int index, const char* key, const std::shared_ptr<JsonValue>& child) {
        insertChild(index,std::string(key),child);
    }

    void appendValue(bool value) {
        appendChild(JsonValue::alloc(value));
    }
    
    void appendValue(const std::string& key, bool value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void appendValue(const char* key, bool value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void insertValue(unsigned int index, bool value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const std::string& key, bool value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const char* key, bool value) {
        insertChild(index,JsonValue::alloc(value));
    }
    
    void appendValue(long value) {
        appendChild(JsonValue::alloc(value));
    }
    
    void appendValue(const std::string& key, long value)  {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void appendValue(const char* key, long value)  {
        appendChild(key,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, long value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const std::string& key, long value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const char* key, long value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void appendValue(double value)  {
        appendChild(JsonValue::alloc(value));
    }
    
    void appendValue(const std::string& key, double value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void appendValue(const char* key, double value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void insertValue(unsigned int index, double value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const std::string& key, double value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const char* key, double value) {
        insertChild(index,JsonValue::alloc(value));
    }
    
    void appendValue(const std::string& value) {
        appendChild(JsonValue::alloc(value));
    }
    
    void appendValue(const char* value) {
        appendChild(JsonValue::alloc(value));
    }
    
    void appendValue(const std::string& key, const std::string& value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void appendValue(const std::string& key, const char* value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void appendValue(const char* key, const std::string& value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void appendValue(const char* key, const char* value) {
        appendChild(key,JsonValue::alloc(value));
    }
    
    void insertValue(unsigned int index, const std::string& value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const char* value) {
        insertChild(index,JsonValue::alloc(value));
    }
    
    void insertValue(unsigned int index, const std::string& key, const std::string& value) {
        insertChild(index,JsonValue::alloc(value));
    }

    void insertValue(unsigned int index, const std::string& key, const char* value) {
        insertChild(index,JsonValue::alloc(value));
    }
    
    void insertValue(unsigned int index, const char* key, const std::string& value) {
        insertChild(index,JsonValue::alloc(value));
    }
    
    void insertValue(unsigned int index, const char* key, const char* value) {
        insertChild(index,JsonValue::alloc(value));
    }
    
    
    void appendNull()  {
        appendChild(JsonValue::allocNull());
    }
    
    void appendNull(const std::string& key) {
        appendChild(key,JsonValue::allocNull());
    }
    
    void appendNull(const char* key) {
        appendChild(key,JsonValue::allocNull());
    }
    
    void insertNull(unsigned int index) {
        insertChild(index,JsonValue::allocNull());
    }
    
    void insertNull(unsigned int index, const std::string& key) {
        insertChild(index,JsonValue::allocNull());
    }
    
    void insertNull(unsigned int index, const char* key) {
        insertChild(index,JsonValue::allocNull());
    }
    
    void appendArray() {
        appendChild(JsonValue::allocArray());
    }
    
    void appendArray(const std::string& key) {
        appendChild(key,JsonValue::allocArray());
    }

    void appendArray(const char* key) {
        appendChild(key,JsonValue::allocArray());
    }
    
    void insertArray(unsigned int index) {
        insertChild(index,JsonValue::allocArray());
    }

    void insertArray(unsigned int index, const std::string& key) {
        insertChild(index,key,JsonValue::allocArray());
    }

    void insertArray(unsigned int index, const char* key) {
        insertChild(index,key,JsonValue::allocArray());
    }
    
    void appendObject() {
        appendChild(JsonValue::allocObject());
    }
    
    void appendObject(const std::string& key) {
        appendChild(key,JsonValue::allocObject());
    }
    
    void appendObject(const char* key) {
        appendChild(key,JsonValue::allocObject());
    }
    
    void insertObject(unsigned int index) {
        insertChild(index,JsonValue::allocObject());
    }
    
    void insertObject(unsigned int index, const std::string& key) {
        insertChild(index,key,JsonValue::allocObject());
    }

    void insertObject(unsigned int index, const char* key) {
        insertChild(index,key,JsonValue::allocObject());
    }


#pragma mark -
#pragma mark Encoding
    
    std::string toString(bool format=true) const;

};

}
#endif /* __CU_JSON_VALUE_H__ */