c@5: #include <string>
c@5: #include <cstdio>
c@5: #include <cstring>
c@5: #include <iostream>
c@5: #include <sstream>
c@5: #include "json11.hpp"
c@5: #include <cassert>
c@5: #include <list>
c@5: #include <set>
c@5: #include <unordered_map>
c@5: 
c@5: using namespace json11;
c@5: using std::string;
c@5: 
c@5: // Check that Json has the properties we want.
c@5: #include <type_traits>
c@5: #define CHECK_TRAIT(x) static_assert(std::x::value, #x)
c@5: CHECK_TRAIT(is_nothrow_constructible<Json>);
c@5: CHECK_TRAIT(is_nothrow_default_constructible<Json>);
c@5: CHECK_TRAIT(is_copy_constructible<Json>);
c@5: CHECK_TRAIT(is_nothrow_move_constructible<Json>);
c@5: CHECK_TRAIT(is_copy_assignable<Json>);
c@5: CHECK_TRAIT(is_nothrow_move_assignable<Json>);
c@5: CHECK_TRAIT(is_nothrow_destructible<Json>);
c@5: 
c@5: void parse_from_stdin() {
c@5:     string buf;
c@5:     string line;
c@5:     while (std::getline(std::cin, line)) {
c@5:         buf += line + "\n";
c@5:     }
c@5: 
c@5:     string err;
c@5:     auto json = Json::parse(buf, err);
c@5:     if (!err.empty()) {
c@5:         printf("Failed: %s\n", err.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json.dump().c_str());
c@5:     }
c@5: }
c@5: 
c@5: int main(int argc, char **argv) {
c@5:     if (argc == 2 && argv[1] == string("--stdin")) {
c@5:         parse_from_stdin();
c@5:         return 0;
c@5:     }
c@5: 
c@5:     const string simple_test =
c@5:         R"({"k1":"v1", "k2":42, "k3":["a",123,true,false,null]})";
c@5: 
c@5:     string err;
c@5:     auto json = Json::parse(simple_test, err);
c@5: 
c@5:     std::cout << "k1: " << json["k1"].string_value() << "\n";
c@5:     std::cout << "k3: " << json["k3"].dump() << "\n";
c@5: 
c@5:     for (auto &k : json["k3"].array_items()) {
c@5:         std::cout << "    - " << k.dump() << "\n";
c@5:     }
c@5: 
c@5:     const string comment_test = R"({
c@5:       // comment /* with nested comment */
c@5:       "a": 1,
c@5:       // comment
c@5:       // continued
c@5:       "b": "text",
c@5:       /* multi
c@5:          line
c@5:          comment */
c@5:       // and single-line comment
c@5:       "c": [1, 2, 3]
c@5:     })";
c@5: 
c@5:     string err_comment;
c@5:     auto json_comment = Json::parse(
c@5:       comment_test, err_comment, JsonParse::COMMENTS);
c@5:     if (!err_comment.empty()) {
c@5:         printf("Failed: %s\n", err_comment.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json_comment.dump().c_str());
c@5:     }
c@5: 
c@5:     string failing_comment_test = R"({
c@5:       /* bad comment
c@5:       "a": 1,
c@5:     })";
c@5: 
c@5:     string err_failing_comment;
c@5:     auto json_failing_comment = Json::parse(
c@5:       failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
c@5:     if (!err_failing_comment.empty()) {
c@5:         printf("Failed: %s\n", err_failing_comment.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json_failing_comment.dump().c_str());
c@5:     }
c@5: 
c@5:     failing_comment_test = R"({
c@5:       / / bad comment })";
c@5: 
c@5:     json_failing_comment = Json::parse(
c@5:       failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
c@5:     if (!err_failing_comment.empty()) {
c@5:         printf("Failed: %s\n", err_failing_comment.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json_failing_comment.dump().c_str());
c@5:     }
c@5: 
c@5:     failing_comment_test = R"({// bad comment })";
c@5: 
c@5:     json_failing_comment = Json::parse(
c@5:       failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
c@5:     if (!err_failing_comment.empty()) {
c@5:         printf("Failed: %s\n", err_failing_comment.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json_failing_comment.dump().c_str());
c@5:     }
c@5: 
c@5:     failing_comment_test = R"({
c@5:           "a": 1
c@5:         }/)";
c@5: 
c@5:     json_failing_comment = Json::parse(
c@5:       failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
c@5:     if (!err_failing_comment.empty()) {
c@5:         printf("Failed: %s\n", err_failing_comment.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json_failing_comment.dump().c_str());
c@5:     }
c@5: 
c@5:     failing_comment_test = R"({/* bad
c@5:                                   comment *})";
c@5: 
c@5:     json_failing_comment = Json::parse(
c@5:       failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
c@5:     if (!err_failing_comment.empty()) {
c@5:         printf("Failed: %s\n", err_failing_comment.c_str());
c@5:     } else {
c@5:         printf("Result: %s\n", json_failing_comment.dump().c_str());
c@5:     }
c@5: 
c@5:     std::list<int> l1 { 1, 2, 3 };
c@5:     std::vector<int> l2 { 1, 2, 3 };
c@5:     std::set<int> l3 { 1, 2, 3 };
c@5:     assert(Json(l1) == Json(l2));
c@5:     assert(Json(l2) == Json(l3));
c@5: 
c@5:     std::map<string, string> m1 { { "k1", "v1" }, { "k2", "v2" } };
c@5:     std::unordered_map<string, string> m2 { { "k1", "v1" }, { "k2", "v2" } };
c@5:     assert(Json(m1) == Json(m2));
c@5: 
c@5:     // Json literals
c@5:     Json obj = Json::object({
c@5:         { "k1", "v1" },
c@5:         { "k2", 42.0 },
c@5:         { "k3", Json::array({ "a", 123.0, true, false, nullptr }) },
c@5:     });
c@5: 
c@5:     std::cout << "obj: " << obj.dump() << "\n";
c@5: 
c@5:     assert(Json("a").number_value() == 0);
c@5:     assert(Json("a").string_value() == "a");
c@5:     assert(Json().number_value() == 0);
c@5: 
c@5:     assert(obj == json);
c@5:     assert(Json(42) == Json(42.0));
c@5:     assert(Json(42) != Json(42.1));
c@5: 
c@5:     const string unicode_escape_test =
c@5:         R"([ "blah\ud83d\udca9blah\ud83dblah\udca9blah\u0000blah\u1234" ])";
c@5: 
c@5:     const char utf8[] = "blah" "\xf0\x9f\x92\xa9" "blah" "\xed\xa0\xbd" "blah"
c@5:                         "\xed\xb2\xa9" "blah" "\0" "blah" "\xe1\x88\xb4";
c@5: 
c@5:     Json uni = Json::parse(unicode_escape_test, err);
c@5:     assert(uni[0].string_value().size() == (sizeof utf8) - 1);
c@5:     assert(std::memcmp(uni[0].string_value().data(), utf8, sizeof utf8) == 0);
c@5: 
c@5:     // Demonstrates the behavior change in Xcode 7 / Clang 3.7 described
c@5:     // here: https://llvm.org/bugs/show_bug.cgi?id=23812
c@5:     Json nested_array = Json::array { Json::array { 1, 2, 3 } };
c@5:     assert(nested_array.is_array());
c@5:     assert(nested_array.array_items().size() == 1);
c@5:     assert(nested_array.array_items()[0].is_array());
c@5:     assert(nested_array.array_items()[0].array_items().size() == 3);
c@5: 
c@5:     Json my_json = Json::object {
c@5:         { "key1", "value1" },
c@5:         { "key2", false },
c@5:         { "key3", Json::array { 1, 2, 3 } },
c@5:     };
c@5:     std::string json_str = my_json.dump();
c@5:     printf("%s\n", json_str.c_str());
c@5: 
c@5:     class Point {
c@5:     public:
c@5:         int x;
c@5:         int y;
c@5:         Point (int x, int y) : x(x), y(y) {}
c@5:         Json to_json() const { return Json::array { x, y }; }
c@5:     };
c@5: 
c@5:     std::vector<Point> points = { { 1, 2 }, { 10, 20 }, { 100, 200 } };
c@5:     std::string points_json = Json(points).dump();
c@5:     printf("%s\n", points_json.c_str());
c@5: }