GitHub - beached/json_to_cpp: Generate C++ class from JSON data (original) (raw)

JSON to C++

This program will take either a json file or a URL to a web service and build C++ classes to work with that data. By default, it will create the serialization linkage for the JsonLink library that is part of https://github.com/beached/daw_json_link .

• std::optional is used for optional members(those that are not always there or are null in some cases
• std::string is used for strings
• int64_t is used for integral types
• double is used for real types
• bool is used for boolean types
• classes are given the name of their member suffixed with a "_t"
• identifier names are filtered such that C++ keywords, empty id's, or all number id's are prefixed with _json
• Any character in an id that isn't A-Za-z0-9 or _ will be escaped via 0xXXX
• Autogenerated types are their member name suffixed with a _t.

Running

To output the C++ code to the terminal one just needs to type json_to_cpp_bin --in_file jsonfile.json or for a url something like json_to_cpp_bin --in_file http://ip.jsontest.com/

Command line options
Options:
  --help                                print option descriptions
  --in_file arg                         json source file path or url
  --kv_paths arg                        Specify class members that are key 
                                        value pairs
  --use_jsonlink arg (=1)               Use JsonLink serializaion/deserializati
                                        on
  --has_cpp20 arg (=0)                  Enables use of non-type class template 
                                        arguments
  --output_file arg                     output goes to c++ header file.
  --allow_overwrite arg (=0)            Overwrite existing output files
  --hide_null_only arg (=1)             Do not output json entries that are 
                                        only ever null
  --use_string_view arg (=0)            Use std::string_view instead of 
                                        std::string.  Must ensure buffer is 
                                        available after parsing when this is 
                                        used
  --root_object arg (=root_object)      Name of the nameless root object
  --user_agent arg (=Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.100 Safari/537.36)
                                        User agent to use when downloading via 
                                        URL

Example

H2 JSON Data

{
    "glossary": {
        "title": "example glossary",
        "GlossDiv": {
            "title": "S",
            "GlossList": {
                "GlossEntry": {
                    "ID": "SGML",
                    "SortAs": "SGML",
                    "GlossTerm": "Standard Generalized Markup Language",
                    "Acronym": "SGML",
                    "Abbrev": "ISO 8879:1986",
                    "GlossDef": {
                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
                        "GlossSeeAlso": ["GML", "XML"]
                    },  
                    "GlossSee": "markup"
                }   
            }   
        }   
    }   
}

Generated C++ Code by calling json_to_cpp --in_file name.json

#include <daw/json/daw_json_link.h> #include #include #include

struct GlossDef_t { std::string para; std::vectorstd::string GlossSeeAlso; }; // GlossDef_t

struct GlossEntry_t { std::string ID; std::string SortAs; std::string GlossTerm; std::string Acronym; std::string Abbrev; GlossDef_t GlossDef; std::string GlossSee; }; // GlossEntry_t

struct GlossList_t { GlossEntry_t GlossEntry; }; // GlossList_t

struct GlossDiv_t { std::string title; GlossList_t GlossList; }; // GlossDiv_t

struct glossary_t { std::string title; GlossDiv_t GlossDiv; }; // glossary_t

struct root_object_t { glossary_t glossary; }; // root_object_t

namespace daw::json { template<> struct json_data_contract { static constexpr char const mem_para[] = "para"; static constexpr char const mem_GlossSeeAlso[] = "GlossSeeAlso"; using type = json_member_list< json_string, json_array<mem_GlossSeeAlso, std::string, std::vectorstd::string>>;

static inline auto to_json_data( GlossDef_t const &value ) {
  return std::forward_as_tuple( value.para, value.GlossSeeAlso );
}

}; } namespace daw::json { template<> struct json_data_contract { static constexpr char const mem_ID[] = "ID"; static constexpr char const mem_SortAs[] = "SortAs"; static constexpr char const mem_GlossTerm[] = "GlossTerm"; static constexpr char const mem_Acronym[] = "Acronym"; static constexpr char const mem_Abbrev[] = "Abbrev"; static constexpr char const mem_GlossDef[] = "GlossDef"; static constexpr char const mem_GlossSee[] = "GlossSee"; using type = json_member_list< json_string, json_string, json_string, json_string, json_string, json_class<mem_GlossDef, GlossDef_t>, json_string>;

static inline auto to_json_data( GlossEntry_t const &value ) {
  return std::forward_as_tuple( value.ID, value.SortAs, value.GlossTerm,
                                value.Acronym, value.Abbrev, value.GlossDef,
                                value.GlossSee );
}

}; } namespace daw::json { template<> struct json_data_contract { static constexpr char const mem_GlossEntry[] = "GlossEntry"; using type = json_member_list<json_class<mem_GlossEntry, GlossEntry_t>>;

static inline auto to_json_data( GlossList_t const &value ) {
  return std::forward_as_tuple( value.GlossEntry );
}

}; } namespace daw::json { template<> struct json_data_contract { static constexpr char const mem_title[] = "title"; static constexpr char const mem_GlossList[] = "GlossList"; using type = json_member_list<json_string, json_class<mem_GlossList, GlossList_t>>;

static inline auto to_json_data( GlossDiv_t const &value ) {
  return std::forward_as_tuple( value.title, value.GlossList );
}

}; } namespace daw::json { template<> struct json_data_contract { static constexpr char const mem_title[] = "title"; static constexpr char const mem_GlossDiv[] = "GlossDiv"; using type = json_member_list<json_string, json_class<mem_GlossDiv, GlossDiv_t>>;

static inline auto to_json_data( glossary_t const &value ) {
  return std::forward_as_tuple( value.title, value.GlossDiv );
}

}; } namespace daw::json { template<> struct json_data_contract { static constexpr char const mem_glossary[] = "glossary"; using type = json_member_list<json_class<mem_glossary, glossary_t>>;

static inline auto to_json_data( root_object_t const &value ) {
  return std::forward_as_tuple( value.glossary );
}

}; }