Формат json

///----------------------------------------------------------------------------|
/// "myJson.h"
///----------------------------------------------------------------------------:
#include <iostream>
#include <vector>
#include <iomanip>
#include <fstream>
 
#include <windows.h>
namespace color
{   void set(WORD text = 7, WORD background = 0)
    {   SetConsoleTextAttribute(    GetStdHandle(STD_OUTPUT_HANDLE),
                                    (background << 4) | text      );
    }
};
 
typedef std::string              S;
extern const char*         test_01;
extern const char*         test_02;
extern const char*         test_03;
extern const char*         test_04;
typedef size_t               pos_t;
typedef const wchar_t*     PCWCHAR;
 
#define   l(v) {color::set(10);std::cout << #v << " = " << v << "\n";\
                color::set(  );}
#define  ll(v)  std::cout << #v << " = " << v << "\n"; std::cin.get();
#define lll(v)  std::cout <<  v << "\n";
#define messs(v) std::cout << "MESS >>> "  << v << "\n";
 
#define ASSERT(i,m) if(i) std::wcout << "\nASSERT: " << m << '\n'     \
                                       << "  File: " << __FILE__ << '\n'\
                                       << "  Line: " << __LINE__        \
                                    << "\n\n\a";
#define FORIT(s)  for(; i < s.size() ++i)
#define TABS std::setw(tab) << ""
#define BANNER(v1,v2,v3) std::wcout << L##v1 << "\n" << L##v2\
                                    << "\n" << L##v3 << "\n";
 
#define EXCEPTERROR(A) new fun::Exception(L##A, __FILE__, __LINE__)
//  throw(EXCEPTERROR("Нарушение ..."));
#define CHECK_ERROR_END_JSON(A) if(A == std::string::npos)\
                                throw(EXCEPTERROR("Неожиданный конец Json"));
 
namespace fun
{
    struct  Exception
    {       Exception(PCWCHAR _mess, const char* _file, int _line)
                  : mess(_mess),
                    file(_file),
                    line(_line)
            {}
        PCWCHAR     mess;
        const char* file;
        int         line;
 
        void what()
        {   color::set(12);
            std::wcout << '\n'
                       << "ERROR   : " << mess << '\n'
                       << "    FILE: " << file << '\n'
                       << "    LINE: " << line << "\n\n"; color::set();
        }
    };
 
    static S get_name(S& s, pos_t& i)
    {   pos_t start = s.find_first_not_of(" ,\n\\", i);
        CHECK_ERROR_END_JSON(start)
 
        if(s[start] == '}' || s[start] == ']')
        {   i = start - 1;
            return "";
        }
 
        i = s.find_first_of(" :{[",   start);
        CHECK_ERROR_END_JSON(i)
 
        return s.substr(start + 1, i - start - 2);
    }
 
    static S get_after_name(S& s, pos_t& i)
    {   pos_t start = s.find_first_not_of(", :\n\\", i);
        CHECK_ERROR_END_JSON(start)
 
        const bool isob = s[start] == '{' || s[start] == '[';
        if        (isob)
        {   i = start;
            return "";
        }
 
        if(s[start] == '\"') i = s.find         ("\"",       start + 1) + 1;
        else                 i = s.find_first_of(" ,]\n\\}", start    );
        CHECK_ERROR_END_JSON(i)
 
        return s.substr(start, i - start);
    }
 
    int mem_leeks = 0;
    void info_mem_leeks()
    {   if(mem_leeks == 0) return;
                                        BANNER(
    "///------------------------------------|",
    "/// WARNING: Обнаружена утечка памяти! |",
    "///------------------------------------:")
        color::set(12);
               std::cout << "mem_leeks: " << mem_leeks << '\n';
        color::set(  );
    }
 
    bool is_file_or_test(std::string& s)
    {
        pos_t i = s.rfind(".");
        if(i == std::string::npos) return false;
        if(s.substr(i, s.size() - i) == ".json")
        {
            std::string tmp;
            std::ifstream ifs(s);
            if(ifs.is_open())
            {
                std::getline(ifs, tmp, '\f');
                std::swap(tmp, s);
                return true;
            }
            else
            {   throw(EXCEPTERROR("Файл \"*.json\" не найден!"));
            }
        }
        else return false;
    }
}
 
///----------------------------------------------------------------------------|
/// myJson
///----------------------------------------------------------------------------:
struct myJson
{   myJson(const char* str) : s(str), cnt1(0), cnt2(0), tab(0)
    {
        fun::is_file_or_test(s);
 
        pos_t p = 0;
        p = s.find("{");
 
        root  = new Node;
        parse(p,   root);
        ASSERT(0 != cnt1, L"Нарушение парности '{}'");
        ASSERT(0 != cnt2, L"Нарушение парности '[]'");
    }
   ~myJson()
    {   delete_all(root);
        delete root;
        fun::info_mem_leeks();
    }
 
    struct  Node;
    typedef Node pole_t;
    typedef Node  obj_t;
 
    enum eWHAT_THIS
    {   THIS_VALUE ,
        THIS_OBJECT,
        THIS_ARRAY
    };
 
private:
    void delete_all(obj_t* o)
    {   for(const auto& e : o->v)
        {   if(e->v.size() > 0) delete_all(e);
            delete e;
        }
    }
 
    void print_eWHAT_THIS(eWHAT_THIS n)
    {   color::set(10);
        std::cout << '\n';
        switch(n)
        {   case THIS_VALUE : std:: cout << "THIS_VALUE" ; break;
            case THIS_OBJECT: std:: cout << "THIS_OBJECT"; break;
            case THIS_ARRAY : std:: cout << "THIS_ARRAY" ; break;
        }
        color::set();
    }
 
public:
    struct Node
    {   Node() : ETYPE(THIS_VALUE){}
        std::string            name;
        std::string          svalue;
        std::vector<pole_t*>      v;
        pos_t                 start;
 
        eWHAT_THIS            ETYPE;
        unsigned char      value[8];
 
        template<class T>
        void push(S name, T n)
        {   pole_t* p         = new Node;
                    p->name   = name;
                    p->svalue = std::to_string(n);
            v.push_back(p);
        }
        void push(S name, S n)
        {   pole_t* p         = new Node;
                    p->name   = name;
                    p->svalue =  S("\"") + n + "\"";
            v.push_back(p);
        }
 
        S get(S name)
        {   for(const auto& e : v)
            {   if(e->name == name)
                {   if(e->svalue[0] == '\"')
                         return e->svalue.substr(1, e->svalue.size() - 2);
                    else return e->svalue;
                }
            }
            static S z;
            return   z;
        }
 
        void* operator new(size_t size)
        {   ++fun::mem_leeks;
            return malloc(size);
        }
 
        void operator delete(void *p)
        {   --fun::mem_leeks;
            free(p);
        }
    };
 
    Node*  root;
 
private:
    S         s;
    size_t cnt1;
    size_t cnt2;
 
    ///-------------------------------------------------------------------parse:
    void parse(pos_t& i, obj_t* o)
    {
        ASSERT(s[i] != '{', "Отсутствует cимвол '{'");
        o->ETYPE = THIS_OBJECT;
 
        for(; i < s.size() && s[i] != '}';)
        {   pole_t*        p = new pole_t;
            o->v.push_back(p);
 
            p->name = fun::get_name(s, ++i);
 
            i = s.find_first_not_of(" :\n\\", i);
            CHECK_ERROR_END_JSON(i)
 
            switch(s[i])
            {
                case '{': ++cnt1; parse(i, p); --cnt1; ++i; break;////////////-!
                case '[':   parse_array(i, p);         ++i; break;
                case '}': o->v.pop_back(); delete p;        return;
                default:  p->svalue = fun::get_after_name(s, i);
            }
 
            i = s.find_first_of(",}", i);
            CHECK_ERROR_END_JSON(i)
        }
    }
 
    ///-------------------------------------------------------------parse_array:
    void parse_array(pos_t& i, obj_t* o)
    {   ASSERT(s[i] != '[', "Отсутствует cимвол '['");
        o->ETYPE = THIS_ARRAY;
 
        for(; i < s.size();)
        {   pole_t*        p = new pole_t;
            o->v.push_back(p);
 
            p->svalue = fun::get_after_name(s, ++i);
 
            i = s.find_first_of("{[]},", i);
            CHECK_ERROR_END_JSON(i)
 
            if(s[i] == '{')
            {   parse(i, p);
            }
            else if(s[i] == '[')
            {   ++cnt2;
                  parse_array(i, p);
                --cnt2;
                i = s.find_first_of("{[]},", ++i);
                CHECK_ERROR_END_JSON(i)
 
                if(s[i] == ']') return;
            }
            else if(s[i] == ']')
            {   return;
            }
        }
    }
 
public:
    void info()
    {   lll("info()------------------------------------------------:")
        info(root);
    }
 
private:
    int tab;
    size_t format_maxwide(const std::vector<pole_t*>& v) const
    {   size_t maxwide = 0;
        for(const auto& e : v)
        {   if(e->name.size() > maxwide) maxwide = e->name.size();
        }
        return maxwide;
    }
 
    ///--------------------------------------------------------------------info:
    void info(obj_t* o)
    {   size_t maxwide = format_maxwide(o->v);
 
        if(o->name.size())
        {   color::set(11);
                   std::cout << TABS << std::setw(maxwide) << o->name <<" = \n";
            color::set();
        }
 
        color::set(12); std::cout << TABS << "{\n"; color::set();
 
        tab += 4;
 
        for(const auto& e : o->v)
        {   switch(e->ETYPE)
            {
                case THIS_OBJECT: info      (e); break;
                case THIS_ARRAY : info_array(e); break;
                case THIS_VALUE:
                {   color::set(10);
                           std::cout << TABS << std::setw(maxwide) << e->name;
                    color::set();
 
                    if(e->svalue[0] != '\"') color::set(15);
                    std::cout   << " = " << e->svalue << '\n';
                    color::set();
                    break;
                }
            }
        }
 
        tab -= 4;
        color::set(12); std::cout << TABS << "}\n"; color::set();
    }
 
    ///--------------------------------------------------------------info_array:
    void info_array(obj_t* o)
    {   color::set(13);
        if(o->name.size())
        {   color::set(13); std::cout << TABS << o->name; color::set();
            std::cout << " = \n";
        }
        color::set(12); std::cout << TABS << "[\n"; color::set();
 
        tab += 4;
 
        size_t cnt = 0;
        if(o->v[0]->svalue.size()) std::cout << TABS;
 
        for(const auto& e : o->v)
        {   switch(e->ETYPE)
            {
                case THIS_OBJECT: info      (e); break;
                case THIS_ARRAY : info_array(e); break;
                case THIS_VALUE :
                {
                    std::cout << e->svalue;
                    if(cnt != o->v.size() - 1) std::cout << ',';
                    std::cout << ' ';
 
                    break;
                }
            }
            ++cnt;
        }
 
        tab -= 4;
        color::set(12); std::cout  << "\n" << TABS << "]\n"; color::set();
    }
 
public:
    obj_t* create(S name)
    {   pole_t* p = new Node;
                p->name  = name;
                p->ETYPE = THIS_OBJECT;
        root->v.push_back(p);
 
        return p;
    }
 
    obj_t* find_object(S name, obj_t* o)
    {   for(const auto& e : o->v)
        {   if(e->ETYPE == THIS_OBJECT)
            {
                if(e->name == name) return e;
                find_object(name, e);
            }
        }
        return nullptr;
    }
};
 
template<class T>
myJson& operator<<(myJson& json, T o)
{   o.serial(json);
    return json;
}
 
template<class T>
myJson& operator>>(myJson& json, T& o)
{   o.deserial(json);
    return json;
}
 
#define SERIAL(A, B) void serial(myJson& json)\
    {                                         \
        myJson::obj_t* p = json.create(#A);   \
                       B                      \
    }
#define PUSH(C)    p->push(#C, C);
 
#define DESERIAL(A, B) void deserial(myJson& json)             \
    {                                                          \
        myJson::obj_t* p = json.find_object(#A, json.root);\
                       B                                       \
    }
#define GETS(C)    C = p->get(#C);
#define GETI(C)    C = std::stoi(p->get(#C));
 
///----------------------------------------------------------------------------|
/// struct Test
///----------------------------------------------------------------------------:
struct Test
{   S name;
    int  n;
 
    void info()
    {  std::cout << "struct Test::info()-----------------------------------:\n";
       std::cout << "  name = " << name << '\n';
       std::cout << "  n    = " << n    << '\n';
    }
 
    //void serial(myJson& json)
    //{
    //    myJson::obj_t* p = json.create("Test");
    //                   p->push("name", name);
    //                   p->push("n"   , n   );
    //}
 
    SERIAL( Test,
        {   PUSH(name)
            PUSH(n)
        }
    )
 
    //void deserial(myJson& json)
    //{
    //    myJson::obj_t* p    = json.find_object("Test", json.root);
    //                   name = p->get("name");
    //                   n    = std::stoi(p->get("n"));
    //}
 
    DESERIAL(Test,
        {
            GETS(name)
            GETI(n)
        }
    )
};
 
inline void testclass_myJson()
{   std::cout << std::left;
    try
    {
        BANNER(
        "///------------------------|",
        "/// Загрузка Json в граф.  |",
        "///------------------------:")
        myJson json(test_04);
      //myJson json("01.json");
               json.info();
 
        BANNER(
        "///------------------------|",
        "/// Загрузка Test в граф.  |",
        "///------------------------:")
        Test    test{"myname", 2042};
        json << test;
 
               json.info(  );
 
        BANNER(
        "///------------------------|",
        "/// Чтение Test2 из графа. |",
        "///------------------------:")
        Test    test2;
        json >> test2;
                test2.info();
 
    }
    catch(fun::Exception* p)
    {   p->what();
    }
}
 
/*-*****************************************************************************
 
Три метода:
 
1. Парсинг объекта.
2.  ...   значения.
3.  ...    массива.
 
Начало отчета от символа ':'
 
Объект:
    всегда начинается с символа '{' и заканчивается '}'
 
Значение:
    первый любой символ, кроме '{' и '['
 
Массив:
    всегда начинается с '['
 
Node универсальная единица, которая и значение, и объект, и массив.
 
*******************************************************************************/

///----------------------------------------------------------------------------|
/// Простой парсер JSON (Demo - 0.1)
///----------------------------------------------------------------------------:
/// Doc:
///     Json json("file.json"); // Загрузка json из файла в память.
///
///----------------------------------------------------------------------------|
#include "myJson.h"
 
void test_all()
{   testclass_myJson();
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
    test_all      ();
    std::cin.get  ();
}
 
const char* test_04 =
R"({
    "Person1" :
    {   "Name"  : "Vasia"        ,
        "Telef" : 111            ,
        "Person2" :
        {   "Name"  : "Vasia"    ,
            "Telef" : 222        ,
            "Person3" :
            {
            }
        }
    }
}
)";
 
const char* test_03 =
R"({
    "Person1" :
    {   "Name"  : "Vasia"        ,
        "Telef" : 111            ,
        "Person2" :
        {   "Name"  : "Vasia"    ,
            "Telef" : 222        ,
            "Person3" :
            {   "Name"  : "Vasia",
                "Telef" : 333
            }
        }
    }                            ,
    "val01" : true               ,
    "val02" : 2020               ,
    "array2D" : [[1,2],[3,4,5]]    ,
    "end" : "endjson"
})";
 
const char* test_02 =
R"({
"Person" :
    {   "Name"  : "Vasia",
        "Telef" : 777
    },
    "const" : true,
    "year"  : 2020,
    "array" : [1,2,3,4,5],
    "array2D" : [[1,2],[3,4], [ 5 , 6 ] ,[7,8],[9,0]],
    "end" : "endjson"
})";
 
const char* test_01 =
R"({
"data" :
    {
        "val_01"    :  111,                   \
        "val_02"    : "222",                  \
        "object_01" :                         \
            {                                 \
                "one"     :   111999,         \
                "two"     :  "222999",        \
                "two2"    :  "2----9",        \
                "array01" :                   \
                    [ {"one" : 888111999},    \
                      {"two" : 888111666}     \
                    ],                        \
                "Person" :                    \
                    {                         \
                        "name"   : "Vasia",   \
                        "Age"    : 25,        \
                        "array2" : [1,2,3,4], \
                        "BDay"   :            \
                            {   "Day"   : 22, \
                                "Month" : 6,  \
                                "Year"  : 1995\
                            },                \
                        "aaa"    : "bbb"      \
                    }                         \
            },                                \
        "ibool" : true                        \
    },                                        \
"zxc" : 2020,                                 \
"str" : "{zzz} + [xxx]"                       \
})";
 
///----------------------------------------------------------------------------|