emsApplication/applications/ems_datahubs/openjson.cpp

/***************************************************************************
 * Copyright (C) 2023-, openlinyou, <linyouhappy@outlook.com>
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 ***************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <string>
#include <vector>
#include <memory.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <stdarg.h>
#include <string>

#include <hv/hlog.h>

#include "openjson.h"

//#define PRINTF printf
#define PRINTF hloge

#if (defined(_MSC_VER) && (_MSC_VER >= 1400 ))
inline int SNPRINTF(char* buffer, size_t size, const char* format, ...)
{
    va_list va;
    va_start(va, format);
    int result = vsnprintf_s(buffer, size, _TRUNCATE, format, va);
    va_end(va);
    return result;
}
#define SSCANF   sscanf_s
#else
#define SNPRINTF snprintf
#define SSCANF   sscanf
#endif

static inline void doubleToStr(double v, char* buffer, int size)
{
    double tmp = floor(v);
    if (tmp == v)
        SNPRINTF(buffer, size, "%ld", (long)v);
    else
        SNPRINTF(buffer, size, "%g", v);
}

static inline bool strToDouble(const char* str, double* value)
{
    return SSCANF(str, "%lf", value) == 1 ? true : false;
}

static void int32ToStr(int32_t n, char* str, size_t size)
{
    if (str == 0 || size < 1) return;
    str[size - 1] = 0;
    if (size < 2) return;
    if (n == 0)
    {
        str[0] = '0';
        return;
    }
    size_t i = 0;
    char buf[128] = { 0 };
    int32_t tmp = n < 0 ? -n : n;
    while (tmp && i < 128)
    {
        buf[i++] = (tmp % 10) + '0';
        tmp = tmp / 10;
    }
    size_t len = n < 0 ? ++i : i;
    if (len > size)
    {
        len = size;
        i = len - 1;
    }
    str[i] = 0;
    while (1)
    {
        --i;
        if (i < 0 || buf[len - i - 1] == 0) break;
        str[i] = buf[len - i - 1];
    }
    if (i == 0) str[i] = '-';
}

static void int64ToStr(int64_t n, char* str, size_t size)
{
    if (str == 0 || size < 1) return;
    str[size - 1] = 0;
    if (size < 2) return;
    if (n == 0)
    {
        str[0] = '0';
        return;
    }
    size_t i = 0;
    char buf[128] = { 0 };
    int64_t tmp = n < 0 ? -n : n;
    while (tmp && i < 128)
    {
        buf[i++] = (tmp % 10) + '0';
        tmp = tmp / 10;
    }
    size_t len = n < 0 ? ++i : i;
    if (len > size)
    {
        len = size;
        i = len - 1;
    }
    str[i] = 0;
    while (1)
    {
        --i;
        if (i < 0 || buf[len - i - 1] == 0) break;
        str[i] = buf[len - i - 1];
    }
    if (i == 0) str[i] = '-';
}

static int32_t strToInt32(const char* str)
{
    const char* ptr = str;
    if (*ptr == '-' || *ptr == '+') ptr++;
    int32_t tmp = 0;
    while (*ptr != 0)
    {
        if ((*ptr < '0') || (*ptr > '9')) break;
        tmp = tmp * 10 + (*ptr - '0');
        ptr++;
    }
    if (*str == '-') tmp = -tmp;
    return tmp;
}

static int64_t strToInt64(const char* str)
{
    const char* ptr = str;
    if (*ptr == '-' || *ptr == '+') ptr++;
    int64_t temp = 0;
    while (*ptr != 0)
    {
        if ((*ptr < '0') || (*ptr > '9')) break;
        temp = temp * 10 + (*ptr - '0');
        ptr++;
    }
    if (*str == '-') temp = -temp;
    return temp;
}


//JsonBox
OpenJson::Box::Box()
{
}

OpenJson::Box::~Box()
{
    for (size_t i = 0; i < childs_.size(); i++)
    {
        if (childs_[i])
        {
            delete childs_[i];
        }
    }
    childs_.clear();
}

bool OpenJson::Box::remove(OpenJson* node)
{
    if (!node) return false;
    std::vector<OpenJson*>::iterator iter;
    for (iter = childs_.begin(); iter != childs_.end(); iter++)
    {
        if (*iter == node)
        {
            childs_.erase(iter);
            delete node;
            return true;
        }
    }
    return false;
}

//JsonContext
OpenJson::Context::Context()
    :
    data_(0),
    size_(0),
    offset_(0),
    root_(0)
{
}

OpenJson::Context::~Context()
{
}

void OpenJson::Context::startRead()
{
    size_ = rbuffer_.size();
    data_ = (char*)rbuffer_.data();
    offset_ = 0;
}

void OpenJson::Context::startWrite()
{
    wbuffer_.clear();
}

//Segment
OpenJson::Segment::Segment(SegmentType type)
{
    setType(type);
}
OpenJson::Segment::~Segment()
{
}
void OpenJson::Segment::setType(SegmentType type)
{
    type_ = type;
    value_.int64_ = 0;
}
void OpenJson::Segment::clear()
{
    value_.int64_  = 0;
}

void OpenJson::Segment::toString()
{
    switch (type_)
    {
    case NIL:
        content_ = "null";
        break;
    case BOOL:
        content_ = value_.bool_ ? "true" : "false";
        break;
    case INT32:
    {
        char buffer[64] = { 0 };
        int32ToStr(value_.int32_, buffer, sizeof(buffer));
        content_ = buffer;
    }
    break;
    case INT64:
    {
        char buffer[64] = { 0 };
        int64ToStr(value_.int64_, buffer, sizeof(buffer));
        content_ = buffer;
    }
    break;
    case DOUBLE:
    {
        char buffer[64] = { 0 };
        doubleToStr(value_.double_, buffer, sizeof(buffer));
        content_ = buffer;
    }
    break;
    case STRING:
        break;
    default:
        content_.clear();
        break;
    }
}

//OpenJson
bool OpenJson::EnableLog_ = true;

OpenJson OpenJson::NodeNull;
std::string OpenJson::StringNull;

OpenJson::OpenJson(JsonType type)
    :type_(type),
     context_(0),
     wcontext_(0),
     idx_(0),
     len_(0),
     box_(0),
     key_(0),
     segment_(0)
{
}

OpenJson::~OpenJson()
{
    clear();
}

OpenJson* OpenJson::createNode(unsigned char code)
{
    JsonType ctype = UNKNOWN;
    switch (code)
    {
    case '"':
    case '\'':
        ctype = STRING;
        break;
    case '{':
        ctype = OBJECT;
        break;
    case '[':
        ctype = ARRAY;
        break;
    default:
        ctype = NUMBER;
        break;
    }
    OpenJson* node = new OpenJson(ctype);
    return node;
}

OpenJson::JsonType OpenJson::codeToType(unsigned char code)
{
    JsonType ctype = UNKNOWN;
    switch (code)
    {
    case '"':
    case '\'':
        ctype = STRING;
        break;
    case '{':
        ctype = OBJECT;
        break;
    case '[':
        ctype = ARRAY;
        break;
    default:
        ctype = NUMBER;
        break;
    }
    return ctype;
}

const std::string& OpenJson::emptyString()
{
    if (context_)
    {
        context_->stringNull_.clear();
        return context_->stringNull_;
    }
    if (wcontext_)
    {
        wcontext_->stringNull_.clear();
        return wcontext_->stringNull_;
    }
    return OpenJson::StringNull;
}

const std::string& OpenJson::key()
{
    if (key_) return key_->s();
    return emptyString();
}

const char* OpenJson::data()
{
    if (context_ && context_->data_)
    {
        if (idx_ < context_->size_)
        {
            return context_->data_ + idx_;
        }
    }
    Log("JsonNode is Empty");
    return emptyString().c_str();
}

double OpenJson::stringToDouble()
{
    const char* str = data();
    double dval = 0;
    if (!str || strlen(str) == 0)
        dval = (float)(1e+300 * 1e+300) * 0.0F;
    else if (strcmp(str, "true") == 0)
        dval = 1.0;
    else if (strcmp(str, "false") == 0)
        dval = 0.0;
    else
        dval = atof(str);
    return dval;
}

int32_t OpenJson::stringToInt32()
{
    int32_t ret = atoi(data());
    return ret;
}

int64_t OpenJson::stringToInt64()
{
    int64_t ret = atoll(data());
    return ret;
}

const std::string& OpenJson::s()
{
    if (type_ == STRING)
    {
        if (!segment_)
        {
            segment_ = new Segment(Segment::STRING);
            segment_->content_ = data();
        }
        if (segment_->type_ == Segment::STRING)
        {
            return segment_->content_;
        }
        segment_->toString();
        return segment_->content_;
    }
    else if (type_ == NUMBER)
    {
        Log("JsonNode is no STRING");
        if (!segment_)
        {
            if (!context_ || !context_->data_ || len_ < 1)
            {
                return emptyString();
            }
            segment_ = new Segment(Segment::NIL);
            segment_->content_ = data();
            return segment_->content_;
        }
        if (segment_)
        {
            if (segment_->type_ != Segment::NIL)
            {
                segment_->toString();
            }
            return segment_->content_;
        }
    }
    else
    {
        Log("JsonNode is no STRING");
    }
    return emptyString();
}

double OpenJson::d(double def)
{
    if (type_ != NUMBER)
    {
        Log("JsonNode is no NUMBER");
        return def;
    }
    if (segment_ == 0)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            return def;
        }
        segment_ = new Segment(Segment::DOUBLE);
        segment_->value_.double_ = stringToDouble();
    }
    if (segment_->type_ != Segment::DOUBLE)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            Log("JsonNode is no DOUBLE NUMBER");
        }
        else
        {
            segment_->setType(Segment::DOUBLE);
            segment_->value_.double_ = stringToDouble();
        }
    }
    switch (segment_->type_)
    {
    case OpenJson::Segment::BOOL:
        return segment_->value_.bool_;
    case OpenJson::Segment::INT32:
        return (double)segment_->value_.int32_;
    case OpenJson::Segment::INT64:
        return (double)segment_->value_.int64_;
    case OpenJson::Segment::DOUBLE:
        return segment_->value_.double_;
    case OpenJson::Segment::STRING:
        return atof(segment_->content_.c_str());
    default:
        break;
    }
    return def;
}

bool OpenJson::b(bool def)
{
    if (type_ != NUMBER)
    {
        Log("JsonNode is no NUMBER");
        return def;
    }
    if (segment_ == 0)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            return def;
        }
        segment_ = new Segment(Segment::BOOL);
        segment_->value_.bool_ = stringToDouble() != 0 ? true : false;
    }
    if (segment_->type_ != Segment::BOOL)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            Log("JsonNode is no BOOL NUMBER");
        }
        else
        {
            segment_->setType(Segment::BOOL);
            segment_->value_.bool_ = stringToDouble() != 0 ? true : false;
        }
    }
    switch (segment_->type_)
    {
    case OpenJson::Segment::BOOL:
        return segment_->value_.bool_;
    case OpenJson::Segment::INT32:
        return (bool)segment_->value_.int32_;
    case OpenJson::Segment::INT64:
        return (bool)segment_->value_.int64_;
    case OpenJson::Segment::DOUBLE:
        return (bool)segment_->value_.double_;
    case OpenJson::Segment::STRING:
        return segment_->content_.size() > 0;
    default:
        break;
    }
    return def;
}

int32_t OpenJson::i32(int32_t def)
{
    if (type_ != NUMBER)
    {
        Log("JsonNode is no NUMBER");
        return def;
    }
    if (segment_ == 0)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            return def;
        }
        segment_ = new Segment(Segment::INT32);
        segment_->value_.int32_ = stringToInt32();
    }
    if (segment_->type_ != Segment::INT32)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            Log("JsonNode is no INT32 NUMBER");
        }
        else
        {
            segment_->setType(Segment::INT32);
            segment_->value_.int32_ = stringToInt32();
        }
    }
    switch (segment_->type_)
    {
    case OpenJson::Segment::BOOL:
        return segment_->value_.bool_;
    case OpenJson::Segment::INT32:
        return segment_->value_.int32_;
    case OpenJson::Segment::INT64:
        return (int32_t)segment_->value_.int64_;
    case OpenJson::Segment::DOUBLE:
        return (int32_t)segment_->value_.double_;
    case OpenJson::Segment::STRING:
        return atoi(segment_->content_.c_str());
    default:
        break;
    }
    return def;
}

int64_t OpenJson::i64(int64_t def)
{
    if (type_ != NUMBER)
    {
        Log("JsonNode is no NUMBER");
        return def;
    }
    if (segment_ && segment_->type_ == Segment::NIL)
    {
        delete segment_;
        segment_ = 0;
    }
    if (segment_ == 0)
    {
        if (!context_ || !context_->data_ || len_ < 1)
        {
            return def;
        }
        segment_ = new Segment(Segment::INT64);
        segment_->value_.int64_ = stringToInt64();
    }
    if (segment_->type_ != Segment::INT64)
    {
        Log("JsonNode is no INT64 NUMBER");
    }
    switch (segment_->type_)
    {
    case OpenJson::Segment::BOOL:
        return segment_->value_.bool_;
    case OpenJson::Segment::INT32:
        return segment_->value_.int32_;
    case OpenJson::Segment::INT64:
        return segment_->value_.int64_;
    case OpenJson::Segment::DOUBLE:
        return (int64_t)segment_->value_.double_;
    case OpenJson::Segment::STRING:
        return atoll(segment_->content_.c_str());
    default:
        break;
    }
    return def;
}

void OpenJson::operator=(const std::string& val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != STRING) type_ = STRING;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::STRING);
    //const char* ptr = 0;
    for (size_t i = 0; i < val.size(); ++i)
    {
        if (val[i] == '"' || val[i] == '\'')
        {
            segment_->content_.push_back('\\');
        }
        segment_->content_.push_back(val[i]);
    }
}

void OpenJson::operator=(const char* val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != STRING) type_ = STRING;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::STRING);
    segment_->content_.clear();
    const char* ptr = 0;
    for (size_t i = 0; i < strlen(val); ++i)
    {
        ptr = val + i;
        if (*ptr == '"' || *ptr == '\'')
        {
            segment_->content_.push_back('\\');
        }
        segment_->content_.push_back(*ptr);
    }
}

void OpenJson::operator=(bool val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != NUMBER) type_ = NUMBER;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::BOOL);
    segment_->value_.bool_ = val;
}

void OpenJson::operator=(int32_t val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != NUMBER) type_ = NUMBER;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::INT32);
    segment_->value_.int32_ = val;
}

void OpenJson::operator=(uint32_t val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != NUMBER) type_ = NUMBER;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::INT32);
    segment_->value_.int32_ = val;
}

void OpenJson::operator=(int64_t val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != NUMBER) type_ = NUMBER;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::INT64);
    segment_->value_.int64_ = val;
}

void OpenJson::operator=(uint64_t val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container, not element");
        return;
    }
    if (type_ != NUMBER) type_ = NUMBER;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::INT64);
    segment_->value_.int64_ = val;
}

void OpenJson::operator=(double val)
{
    if (type_ == OBJECT || type_ == ARRAY)
    {
        Log("JsonNode is a container");
        return;
    }
    if (type_ != NUMBER) type_ = NUMBER;
    if (segment_ == 0) segment_ = new Segment;
    segment_->setType(Segment::DOUBLE);
    segment_->value_.double_ = val;
}

OpenJson& OpenJson::array(size_t idx)
{
    if (type_ != ARRAY)
    {
        if (type_ == OBJECT)
        {
            Log("JsonNode must be ARRAY, not OBJECT");
        }
        type_ = ARRAY;
    }
    else
    {
        assert(box_);
    }
    if (!box_) box_ = new Box;
    if (idx >= box_->childs_.size())
    {
        box_->childs_.resize(idx + 1, 0);
    }
    OpenJson* child = box_->childs_[idx];
    if (!child)
    {
        child = new OpenJson();
        box_->childs_[idx] = child;
    }
    return *child;
}

OpenJson& OpenJson::object(const char* key)
{
    if (!key)
    {
        return NodeNull;
    }
    if (type_ != OBJECT)
    {
        if (type_ == ARRAY)
        {
            PRINTF("JsonNode must be OBJECT, not ARRAY");
        }
        type_ = OBJECT;
    }
    else
    {
        if( !box_ )
        {
            PRINTF("JsonNode must be OBJECT, not NOTHING! key:[%s]", key);
        }
        assert(box_);
    }
    if (!box_) box_ = new Box;

    OpenJson* child = 0;
    for (size_t i = 0; i < box_->childs_.size(); ++i)
    {
        child = box_->childs_[i];
        if (child == 0) continue;
        if (strcmp(child->key().c_str(), key) == 0)
        {
            return *child;
        }
    }
    OpenJson* keyNode = new OpenJson(STRING);
    *keyNode = key;
    child = new OpenJson();
    child->key_ = keyNode;
    size_t i = 0;
    for (; i < box_->childs_.size(); ++i)
    {
        if (!box_->childs_[i])
        {
            box_->childs_[i] = child;
            break;
        }
    }
    if (i >= box_->childs_.size())
    {
        box_->childs_.push_back(child);
    }
    return *child;
}

void OpenJson::addNode(OpenJson* node)
{
    if (!node) return;
    if (type_ != OBJECT && type_ != ARRAY)
    {
        PRINTF("JsonNode must be OBJECT or ARRAY");
        type_ = node->key_ ? OBJECT : ARRAY;
    }
    if (box_ == 0) box_ = new Box;
    box_->add(node);
}

void OpenJson::removeNode(size_t idx)
{
    if (box_ == 0) return;
    if (idx >= box_->childs_.size()) return;
    box_->remove(box_->childs_[idx]);
}

void OpenJson::removeNode(const char* key)
{
    if (box_ == 0) return;
    OpenJson* child = 0;
    for (size_t i = 0; i < box_->childs_.size(); ++i)
    {
        child = box_->childs_[i];
        if (child == 0) continue;
        if (strcmp(child->key().c_str(), key) == 0)
        {
            box_->remove(child);
            break;
        }
    }
}

void OpenJson::clear()
{
    if (segment_)
    {
        delete segment_;
        segment_ = 0;
    }
    if (key_)
    {
        delete key_;
        key_ = 0;
    }
    if (box_)
    {
        assert(type_ == OBJECT || type_ == ARRAY);
        delete box_;
        box_ = 0;
    }
    if (context_ != 0 && context_->root_ == this)
    {
        context_->root_ = 0;
        delete context_;
    }
    context_ = 0;
    if (wcontext_ != 0 && wcontext_->root_ == this)
    {
        wcontext_->root_ = 0;
        delete wcontext_;
    }
    wcontext_ = 0;
    type_ = EMPTY;
    idx_ = 0;
    len_ = 0;
}

void OpenJson::trimSpace()
{
    if (!context_) return;
    char code  = 0;
    for (size_t i = idx_; i < context_->size_; ++i)
    {
        code = context_->data_[i];
        if (code > ' ')
        {
            idx_ = i;
            break;
        }
    }
}

unsigned char OpenJson::getCharCode()
{
    if (!context_) return 0;
    if (idx_ < context_->size_)
    {
        unsigned char tmp = (unsigned char)context_->data_[idx_];
        return tmp;
    }
    return 0;
}

unsigned char OpenJson::getChar()
{
    unsigned char code = getCharCode();
    if (code <= ' ')
    {
        trimSpace();
        code = getCharCode();
    }
    return code;
}

unsigned char OpenJson::checkCode(unsigned char charCode)
{
    unsigned char code = getCharCode();
    if (code != charCode)
    {
        trimSpace();
        code = getCharCode();
        if (code != charCode) return 0;
    }
    ++idx_;
    return code;
}

size_t OpenJson::searchCode(unsigned char code)
{
    char* data = context_->data_;
    for (size_t i = idx_; i < context_->size_; i++)
    {
        if (data[i] == code)
        {
            if (i > 0 && data[i - 1] != '\\') return i;
        }
    }
    return -1;
}

bool OpenJson::makeRContext()
{
    if (type_ != EMPTY)
    {
        if (context_ && context_->root_ != this)
        {
            PRINTF("OpenJson warn:JsonNode is no root or empty!");
            return false;
        }
    }
    else
    {
        if (context_ && context_->root_ != this)
        {
            PRINTF("OpenJson warn:JsonNode is no root or empty!");
            return false;
        };
    }
    clear();
    context_ = new Context();
    context_->root_ = this;
    context_->offset_ = 0;
    context_->rbuffer_.clear();
    return true;
}

bool OpenJson::decode(const std::string& buffer)
{
    if (!makeRContext()) return false;
    context_->rbuffer_ = buffer;
    context_->startRead();
    type_ = codeToType(getChar());
    try
    {
        read(context_, true);
    }
    catch (const char* error)
    {
        PRINTF("OpenJson warn:decode catch exception %s", error);
    }
    return true;
}

bool OpenJson::decodeFile(const std::string& filePath)
{
    if (!makeRContext()) return false;
    FILE* fp = 0;
#ifdef _MSC_VER
    fopen_s(&fp, filePath.c_str(), "rb");
#else
    fp = fopen(filePath.c_str(), "rb");
#endif
    if (fp == 0)
    {
#ifdef _MSC_VER
        char buffer[1024] = { 0 };
        strerror_s(buffer, sizeof(buffer), errno);
        PRINTF("OpenJson warn:decodeFile error:%s,%s\n", buffer, filePath.c_str());
#else
        PRINTF("OpenJson warn:decodeFile error:%s,%s\n", strerror(errno), filePath.c_str());
#endif
        return false;
    }
    fseek(fp, 0, SEEK_END);
    /*size_t size = */
    ftell(fp);
    fseek(fp, 0, SEEK_SET);

    size_t ret = 0;
    char buff[1024 * 8] = { 0 };
    while (true)
    {
        ret = fread(buff, 1, sizeof(buff), fp);
        if (ret < 0)
        {
#ifdef _MSC_VER
            char buffer[1024] = { 0 };
            strerror_s(buffer, sizeof(buffer), errno);
            PRINTF("OpenJson warn:decodeFile error:%s,%s\n", buffer, filePath.c_str());
#else
            PRINTF("OpenJson warn:decodeFile error:%s,%s\n", strerror(errno), filePath.c_str());
#endif
            fclose(fp);
            return false;
        }
        else if(ret == 0) break;
        context_->rbuffer_.append(buff, ret);
    }
    fclose(fp);

    context_->startRead();
    type_ = codeToType(getChar());
    try
    {
        read(context_, true);
    }
    catch (const char* error)
    {
        PRINTF("OpenJson warn:decodeFile catch exception %s", error);
    }
    return true;
}

const std::string& OpenJson::encode()
{
    if (wcontext_ == 0)
    {
        wcontext_ = new Context();
        wcontext_->root_ = this;
    }
    wcontext_->startWrite();
    write(wcontext_, true);
    return wcontext_->wbuffer_;
}

void OpenJson::encodeFile(const std::string& filePath)
{
    FILE* fp = 0;
#ifdef _MSC_VER
    fopen_s(&fp, filePath.c_str(), "wb");
#else
    fp = fopen(filePath.c_str(), "wb");
#endif
    if (fp == 0)
    {
#ifdef _MSC_VER
        char buffer[1024] = { 0 };
        strerror_s(buffer, sizeof(buffer), errno);
        PRINTF("OpenJson warn:encodeFile error:%s,%s\n", buffer, filePath.c_str());
#else
        PRINTF("OpenJson warn:encodeFile error:%s,%s\n", strerror(errno), filePath.c_str());
#endif
        return;
    }
    fseek(fp, 0, SEEK_SET);
    const std::string& buffer = encode();
    fwrite(buffer.data(), buffer.size(), 1, fp);
    fclose(fp);
}

void OpenJson::read(Context* context, bool isRoot)
{
    if (context_)
    {
        if (isRoot)
        {
            assert(context_ == context);
            assert(context_->root_ == this);
        }
        else
        {
            assert(context_->root_ != this);
            if (context_->root_ == this) return;
        }
    }
    len_     = 0;
    context_ = context;
    idx_     = context->offset_;
    switch (type_)
    {
    case EMPTY:
        break;
    case STRING:
        readString();
        break;
    case NUMBER:
        readNumber();
        break;
    case OBJECT:
        readObject();
        break;
    case ARRAY:
        readArray();
        break;
    case UNKNOWN:
        break;
    default:
        break;
    }
}
void OpenJson::readNumber()
{
    assert(type_ == NUMBER);
    unsigned char code = 0;
    size_t sidx = idx_;
    size_t len  = context_->size_;
    char* data  = context_->data_;
    for (; idx_ < len; idx_++)
    {
        code = data[idx_];
        if (code == ',' || code == '}' || code == ']')
        {
            idx_--;
            break;
        }
    }
    if (idx_ < sidx)
    {
        throwError("lost number value");
        return;
    }
    len_ = idx_ - sidx + 1;
    idx_ = sidx;
}
void OpenJson::readString()
{
    assert(type_ == STRING);
    unsigned char code = '"';
    if (!checkCode(code))
    {
        code = '\'';
        if (!checkCode(code))
        {
            throwError("lost '\"' or \"'\"");
            return;
        }
    }
    size_t sidx = idx_;
    size_t eidx = searchCode(code);
    if (eidx < 0)
    {
        throwError("lost '\"' or \"'\"");
        return;
    }
    idx_ = sidx;
    len_ = eidx - sidx + 1;
    context_->data_[eidx] = 0;
}
void OpenJson::readObject()
{
    assert(type_ == OBJECT);
    if (!checkCode('{'))
    {
        throwError("lost '{'");
        return;
    }
    unsigned char code = 0;
    OpenJson* keyNode  = 0;
    OpenJson* valNode  = 0;
    size_t oidx = idx_;
    while (idx_ < context_->size_)
    {
        code = getChar();
        if (code == 0)
        {
            throwError("lost '}'");
            return;
        }
        if (checkCode('}')) break;
        keyNode = createNode(code);
        if (keyNode->type_ != STRING)
        {
            throwError("lost key");
            return;
        }
        context_->offset_ = idx_;
        keyNode->read(context_);
        idx_ = keyNode->idx_ + keyNode->len_;
        if (!checkCode(':'))
        {
            throwError("lost ':'");
            return;
        }
        code    = getChar();
        valNode = createNode(code);
        valNode->key_ = keyNode;
        context_->offset_ = idx_;
        valNode->read(context_);
        idx_ = valNode->idx_ + valNode->len_;
        addNode(valNode);

        if (checkCode('}'))
        {
            context_->data_[idx_ - 1] = 0;
            break;
        }
        if (!checkCode(','))
        {
            throwError("lost ','");
            return;
        }
        context_->data_[idx_ - 1] = 0;
    }
    len_ = idx_ - oidx;
    idx_ = oidx;
}
void OpenJson::readArray()
{
    assert(type_ == ARRAY);
    if (!checkCode('['))
    {
        throwError("lost '['");
        return;
    }
    unsigned char code = 0;
    OpenJson* valNode  = 0;
    size_t oidx = idx_;
    while (idx_ < context_->size_)
    {
        code = getChar();
        if (code == 0)
        {
            throwError("lost ']'");
            return;
        }
        if (checkCode(']')) break;
        valNode = createNode(code);
        context_->offset_ = idx_;
        valNode->read(context_);
        idx_ = valNode->idx_ + valNode->len_;
        addNode(valNode);

        if (checkCode(']'))
        {
            context_->data_[idx_ - 1] = 0;
            break;
        }
        if (!checkCode(','))
        {
            throwError("lost ','");
            return;
        }
        context_->data_[idx_ - 1] = 0;
    }
    len_ = idx_ - oidx;
    idx_ = oidx;
}

void OpenJson::write(Context* context, bool isRoot)
{
    if (wcontext_)
    {
        if (isRoot)
        {
            assert(wcontext_ == context);
            assert(wcontext_->root_ == this);
        }
        else
        {
            assert(wcontext_->root_ != this);
            if (wcontext_->root_ == this) return;
        }
    }
    wcontext_ = context;
    switch (type_)
    {
    case EMPTY:
        break;
    case STRING:
        writeString();
        break;
    case NUMBER:
        writeNumber();
        break;
    case OBJECT:
        writeObject();
        break;
    case ARRAY:
        writeArray();
        break;
    case UNKNOWN:
        break;
    default:
        break;
    }
}
void OpenJson::writeNumber()
{
    assert(type_ == NUMBER);
    if (key_)
    {
        wcontext_->wbuffer_.append("\"" + key() + "\":");
    }
    if (segment_)
    {
        segment_->toString();
        wcontext_->wbuffer_.append(segment_->content_);
    }
    else
    {
        wcontext_->wbuffer_.append(data());
    }
}
void OpenJson::writeString()
{
    assert(type_ == STRING);
    if (key_)
    {
        wcontext_->wbuffer_.append("\"" + key() + "\":");
    }
    wcontext_->wbuffer_.append("\"" + s() + "\"");
}
void OpenJson::writeObject()
{
    assert(type_ == OBJECT);
    if (key_)
        wcontext_->wbuffer_.append("\"" + key() + "\":{");
    else
        wcontext_->wbuffer_.append("{");

    if (box_ != 0)
    {
        size_t idx = 0;
        size_t size = box_->size();
        for (size_t i = 0; i < size; ++i)
        {
            if (!(*box_)[i]) continue;
            if (idx > 0)
            {
                wcontext_->wbuffer_.append(",");
            }
            (*box_)[i]->write(wcontext_);
            ++idx;
        }
    }
    wcontext_->wbuffer_.append("}");
}
void OpenJson::writeArray()
{
    assert(type_ == ARRAY);
    if (key_)
        wcontext_->wbuffer_.append("\"" + key() + "\":[");
    else
        wcontext_->wbuffer_.append("[");

    if (box_ != 0)
    {
        size_t idx  = 0;
        size_t size = box_->size();
        for (size_t i = 0; i < size; ++i)
        {
            if (!(*box_)[i]) continue;
            if (idx > 0)
            {
                wcontext_->wbuffer_.append(",");
            }
            (*box_)[i]->write(wcontext_);
            ++idx;
        }
    }
    wcontext_->wbuffer_.append("]");
}

void OpenJson::EnableLog(bool enable)
{
    EnableLog_ = enable;
}

void OpenJson::Log(const char* format, ...)
{
    if (!EnableLog_) return;
    va_list ap;
    va_start(ap, format);
    char tmp[1024] = { 0 };
    vsnprintf(tmp, sizeof(tmp), format, ap);
    va_end(ap);
    PRINTF("OpenJson WARN:%s\n", tmp);
}
void OpenJson::throwError(const char* errMsg)
{
    static const char* InfoTags[6] = { "EMPTY", "STRING", "NUMBER", "OBJECT", "ARRAY", "UNKNOWN" };
    size_t len = sizeof(InfoTags) / sizeof(InfoTags[0]);
    const char* tab = type_ < len ? InfoTags[type_] : InfoTags[5];
    PRINTF("OpenJson:throwError [%s] Error: %s\n", tab, errMsg);

    char tmp[126] = { 0 };
    len = context_->size_ - context_->offset_;
    len = len > 64 ? 64 : len;
    memcpy(tmp, context_->data_ + idx_, len);
    PRINTF("OpenJson:throwError content:%s\n", tmp);
    throw errMsg;
}