json.h

Go to the documentation of this file.

 
#ifndef _PSP2_JSON_H_
#define _PSP2_JSON_H_
 
#ifdef __cplusplus
 
#include <psp2/types.h>
 
typedef enum SceJsonErrorCode
{
    SCE_JSON_ERROR_UNLOADED              = 0x80920110,
    SCE_JSON_ERROR_LOADED                = 0x80920111,
    SCE_JSON_ERROR_MEM_ALLOC             = 0x80920102,
    SCE_JSON_PARSER_ERROR_EMPTY_BUF      = 0x80920105,
    SCE_JSON_PARSER_ERROR_FILE_LOAD      = 0x80920103,
    SCE_JSON_PARSER_ERROR_INVALID_TOKEN  = 0x80920101,
} SceJsonErrorCode;
 
namespace sce
{
 
namespace Json
{
 
typedef enum class ValueType
{
    NullValue            = 0, 
    BoolValue            = 1, 
    IntValue             = 2, 
    UIntValue            = 3, 
    RealValue            = 4, 
    StringValue          = 5, 
    ArrayValue           = 6, 
    ObjectValue          = 7  
} ValueType;
 
class MemAllocator
{
public:
    MemAllocator();
    virtual ~MemAllocator();
 
    virtual void* allocateMemory(SceSize size, void* userData) = 0;
    virtual void freeMemory(void* ptr, void* userData) = 0;
 
    virtual void notifyError(int errorCode, SceSize size, void* userData);
};
 
class InitParameter
{
public:
    MemAllocator* allocator;
    void* userData;
    SceSize bufSize;
};
 
class Initializer
{
public:
    Initializer();
    ~Initializer();
 
    int initialize(const InitParameter* initParams);
    int terminate();
};
 
class Value;
class Array
{
public:
    class iterator
    {
    public:
        iterator();
        iterator(const iterator& iter);
        ~iterator();
 
        void advance(SceSize adv);
 
        iterator& operator=(const iterator& iter);
        void operator++(int adv);
        void operator++();
        Value& operator*() const;
        bool operator!=(iterator iter) const;
        Value* operator->() const;
    private:
        void* implData; 
    };
 
    Array();
    Array(const Array& arr);
    ~Array();
 
    iterator begin() const;
    iterator end() const;
    iterator insert(const iterator& pos, const Value& val);
    iterator erase(const iterator& pos);
    Value& back() const;
 
    void clear();
    void push_back(const Value& val);
    void pop_back();
 
    SceSize size() const;
    bool empty() const;
 
    Array& operator=(const Array& arr);
 
private:
    void* implData; 
};
 
class String
{
public:
    String();
    String(const char* s);
    String(const String& str);
    ~String();
 
    const static SceSize npos = -1;
 
    String& append(const char* s);
    String& append(const char* s, SceSize pos);
    String& append(const String& str);
 
    String substr(SceSize pos = 0, SceSize len = npos) const;
    char at(SceSize pos) const;
 
    SceSize find(const char* s, SceSize pos) const;
    SceSize find(const char* s, SceSize pos, SceSize n) const;
    SceSize find(const String& str, SceSize pos) const;
    SceSize find(char c, SceSize pos) const;
 
    SceSize rfind(const char* s, SceSize pos) const;
    SceSize rfind(const char* s, SceSize pos, SceSize n) const;
    SceSize rfind(const String& str, SceSize pos) const;
    SceSize rfind(char c, SceSize pos) const;
 
    void clear();
    bool empty() const;
    SceSize size() const;
    SceSize length() const;
    const char* c_str() const;
    void resize(SceSize n);
 
    bool compare(const char* s) const;
    bool compare(const String& str) const;
 
    String& operator+=(const char* s);
    String& operator+=(unsigned char c);
    bool operator==(const char* s) const;
    bool operator==(const String& str) const;
 
    String& operator=(const String& str);
 
private:
    void* implData; 
};
 
class Object;
class Value
{
public:
    typedef int (*SerializeCallback)(String& str, void* userData);
    typedef Value const&(*NullAccessCallback)(ValueType type, const Value* parent, void* userData);
 
    Value();
    Value(ValueType type);
    Value(SceBool value);
    Value(SceInt64 value);
    Value(SceUInt64 value);
    Value(double value);
    Value(const String& value);
    Value(const Array& value);
    Value(const Object& value);
    Value(const Value& value);
    ~Value();
 
    void toString(String& s) const;
 
    void swap(Value& val);
    void clear();
 
    SceSize count() const;
 
    ValueType getType() const;
 
    void set(ValueType type);
    void set(SceBool value);
    void set(SceInt64 value);
    void set(SceUInt64 value);
    void set(double value);
    void set(const String& value);
    void set(const Array& value);
    void set(const Object& value);
    void set(const Value& value);
 
    int setNullAccessCallback(NullAccessCallback cb, void* userData);
 
    Value& getRoot() const;
 
    const SceBool& getBoolean() const;
    const SceInt64& getInteger() const;
    const SceUInt64& getUInteger() const;
    const SceDouble& getReal() const;
    const String& getString() const;
    const Array& getArray() const;
    const Object& getObject() const;
 
    const Value& getValue(SceSize pos) const;
    const Value& getValue(const String& key) const;
 
    SceBool* referBoolean();
    SceInt64* referInteger();
    SceUInt64* referUInteger();
    SceDouble* referReal();
    String* referString();
    Array* referArray();
    Object* referObject();
 
    Value* referValue(SceSize pos);
    Value* referValue(const String& key);
 
    int serialize(String& s);
    int serialize(String& str, SerializeCallback cb, void* userData);
 
    const Value& operator[](const String& key) const;
    const Value& operator[](const char* key) const;
    const Value& operator[](SceSize pos) const;
 
    Value& operator=(const Value& value);
 
    operator bool() const;
 
private:
    Value* parent;         
    NullAccessCallback cb; 
    union
    {
    SceBool boolean;
    SceInt64 integer;
    SceUInt64 uinteger;
    SceDouble real;
    String* string;
    Array* array;
    Object* object;
    } value;              
    char unused[4];       
    ValueType type;       
};
 
class Object
{
public:
    class Pair
    {
    public:
        Pair();
        Pair(const String& name, const Value& value);
        ~Pair();
 
        String key;     
        char unused[4]; 
        Value value;    
    };
    class iterator
    {
    public:
        iterator();
        iterator(const iterator& iter);
        ~iterator();
 
        void advance(SceSize adv);
 
        iterator& operator++(int adv);
        iterator& operator++();
        Pair& operator*() const;
        bool operator==(iterator iter) const;
        bool operator!=(iterator iter) const;
        Pair* operator->() const;
 
        iterator& operator=(const iterator& iter);
 
    private:
        void* implData; 
    };
 
    Object();
    Object(const Object& obj);
    ~Object();
 
    iterator begin() const;
    iterator end() const;
    iterator insert(const Pair& p);
    iterator find(const String& key) const;
    void clear();
    void erase(const String& str);
 
    SceSize size() const;
    bool empty() const;
 
    Value& operator[](const String& str);
 
    Object& operator=(const Object& obj);
 
private:
    void* implData; 
};
 
class Parser
{
public:
    typedef int (*ParseCallback)(char& ch, void* userData);
 
    static int parse(Value& val, ParseCallback cb, void* userData);
 
    static int parse(Value& val, const char* buf, SceSize size);
 
    static int parse(Value& val, const char* path);
};
 
} /* namespace Json */
} /* namespace sce  */
 
#endif /* __cplusplus */
 
#endif /* _PSP2_JSON_H_ */