Json文件解析（下）

Json文件解析（下）

代码地址：https://github.com/nlohmann/json

 

从STL容器转换

任何序列容器（std::array，std::vector，std::deque，std::forward_list，std::list），其值可以被用于构建JSON值（例如，整数，浮点数，布尔值，字符串类型，或者再次在本节中描述STL容器）可被用于创建JSON阵列。这同样适用于类似的关联容器（std::set，std::multiset，std::unordered_set，std::unordered_multiset），但是在这些情况下，数组中的元素的顺序取决于元素是如何在各个STL容器排序。

std ::矢量< INT > c_vector { 1，2，3，4 };

json j_vec（c_vector）;

// [1、2、3、4]

 

std ::双端队列< 双 > c_deque { 1.2，2.3，3.4，5.6 };

json j_deque（c_deque）;

// [1.2、2.3、3.4、5.6]

 

std :: list < bool > c_list { true，true，false，true };

json j_list（c_list）;

// [true，true，false，true]

 

std ::修饰符Modifiers < 的int64_t > c_flist { 12345678909876，23456789098765，34567890987654，45678909876543 };

json j_flist（c_flist）;

// [12345678909876、23456789098765、34567890987654、45678909876543]

 

std ::阵列< 无符号 长，4 > c_array {{ 1，2，3，4 }};

json j_array（c_array）;

// [1、2、3、4]

 

std :: set <std :: string> c_set { “一个”，“两个”，“三个”，“四个”，“一个” };

json j_set（c_set）; //仅使用“一个”的一个条目

// // [“四个”，“一个”，“三个”，“两个”]

 

std :: unordered_set <std :: string> c_uset { “一”，“二”，“三”，“四”，“一” };

json j_uset（c_uset）; //仅使用“一个”的一个条目

// //可能是[“两个”，“三个”，“四个”，“一个”]

 

std :: multiset <std :: string> c_mset { “一个”，“两个”，“一个”，“四个” };

json j_mset（c_mset）; //使用两个用于“一个”的条目

//也许[[一个”，“两个”，“一个”，“四个”]

 

std :: unordered_multiset <std :: string> c_umset { “一”，“二”，“一”，“四” };

json j_umset（c_umset）; //使用两个用于“一个”的条目

//也许[[一个”，“两个”，“一个”，“四个”]

同样，任何缔键值容器（std::map，std::multimap，std::unordered_map，std::unordered_multimap），其键可以构造一个std::string，并且其值可以被用于构建JSON值（见上文实施例）可用于创建一个JSON对象。请注意，在使用多图的情况下，JSON对象中仅使用一个键，并且该值取决于STL容器的内部顺序。

std :: map <std :: string，int > c_map {{ “一个”，1 }，{ “两个”，2 }，{ “三个”，3 }};

json j_map（c_map）;

// {“一个”：1，“三个”：3，“两个”：2}

 

std :: unordered_map < const  char *，double > c_umap {{ “一个”，1.2 }，{ “两个”，2.3 }，{ “三个”，3.4 }};

json j_umap（c_umap）;

// {“一个”：1.2，“两个”：2.3，“三个”：3.4}

 

std :: multimap <std :: string，bool > c_mmap {{ “一个”，true }，{ “两个”，true }，{ “三个”，false }，{ “三个”，true }};

json j_mmap（c_mmap）; //仅使用键“三”的一个条目

// //也许{“一个”：true，“两个”：true，“三个”：true}

 

std :: unordered_multimap <std :: string，bool > c_ummap {{ “一”，true }，{ “二”，true }，{ “三”，false }，{ “三”，true }};

json j_ummap（c_ummap）; //仅使用键“三”的一个条目

// //也许{“一个”：true，“两个”：true，“三个”：true}

JSON指针和JSON补丁

该库支持JSON指针（RFC 6901）作为解决结构化值的替代方法。除此之外，JSON Patch（RFC 6902）允许描述两个JSON值之间的差异-有效地允许Unix已知的patch和diff操作。

// JSON值

json j_original = R“（ {{

  ” baz“：[” one“，” two“，” three“]，

  ” foo“：” bar“

} ）” _json;

 

//使用JSON指针（RFC 6901）访问成员

j_original [ “ / baz / 1 ” _json_pointer];

// “两个”

 

//一个JSON修补程序（RFC 6902）

json j_patch = R“（ [[

  {” op“：” replace“，” path“：” / baz“，” value“：” boo“}，

  {” op“：” add “，” path“：” / hello“，” value“：[” world“]}，

  {” op“：” remove“，” path“：” / foo“}

] ）” _json;

 

//应用补丁

json j_result = j_original.patch（j_patch）;

// {

//     “ baz”：“ boo”，

//     “ hello”：[“ world”]

// }

 

//根据两个JSON值计算JSON补丁

json :: diff（j_result，j_original）;

// [

//    {“ op”：“ replace”，“ path”：“ / baz”，“ value”：[“ one”，“ Two”，“ three”]}，

//    {“ op”：“ remove“，” path“：” / hello“}，

//    {” op“：” add“，” path“：” / foo“，” value“：” bar“}

// ]

JSON合并补丁

该库支持JSON合并补丁（RFC 7386）作为补丁格式。没有使用JSON指针（请参见上文）来指定要操作的值，而是使用一种语法来描述更改，该语法与拟修改的文档非常相似。

// JSON值

json j_document = R“（ {

  ” a“：” b“，

  ” c“：{

    ” d“：” e“，

    ” f“：” g“

  }

}} ）” _json;

 

//补丁

json j_patch = R“（ {

  ” a“：” z“，

  ” c“：{

    ” f“：null

  }

} ）” _json;

 

//应用补丁

j_document.merge_patch（j_patch）;

// {

//   “ a”：“ z”，

//   “ c”：{

//     “ d”：“ e”

//   }

// }

隐式转换

支持的类型可以隐式转换为JSON值。

建议不要使用隐式转换从一个JSON值。可以在此处找到有关此建议的更多详细信息。

//字符串

std :: string s1 = “世界好！” ;

json js = s1;

自动 s2 = js.get <std :: string>（）;

//不推荐

std :: string s3 = js;

std :: string s4;

s4 = js;

 

//布尔

值bool b1 = true ;

json jb = b1;

自动 b2 = jb.get < bool >（）;

//不推荐

bool b3 = jb;

布尔 b4;

b4 = jb;

 

//数字

int i = 42 ;

json jn = i;

自动 f = jn.get < double >（）;

//不推荐使用

double f2 = jb;

双 f3;

f3 = jb;

 

//等

请注意，char类型不会自动转换为JSON字符串，而是自动转换为整数。必须明确指定转换为字符串：

char ch = ' A ' ;                       // ASCII值65

json j_default = ch;                 //存储整数65

json j_string = std :: string（1，ch）;  //存储字符串“ A”

任意类型转换

每种类型都可以用JSON序列化，而不仅仅是STL容器和标量类型。通常，会按照以下方式进行操作：

名称空间 ns {

     // //一个简单的结构，用于对人员进行建模

    struct  person {

        std :: string名称;

        std :: string地址；

        INT年龄;

    };

}

 

ns :: person p = { “ Ned Flanders ”，“ 744 Evergreen Terrace ”，60 };

 

//转换为JSON：将每个值复制到JSON对象中

json j;

j [ “ name ” ] = p.name;

j [ “ address ” ] = p.address;

j [ “ age ” ] = p.age;

 

// ...

 

//从JSON转换：复制JSON对象中的每个值

ns :: person p {

    j [ “ name ” ]。得到 <std :: string>（），

    j [ “ address ” ]。得到 <std :: string>（），

    j [ “年龄” ]。获取 < int >（）

};

可以工作，但是有很多样板...幸运的是，有更好的方法：

//创建一个人

ns :: person p { “ Ned Flanders ”， “ 744 Evergreen Terrace ”， 60 };

 

//转换：person-> json

json j = p;

 

std :: cout << j << std :: endl;

// {“地址”：“ 744 Evergreen Terrace”，“年龄”：60，“名称”：“ Ned Flanders”}

 

//转换：

 json- > person auto p2 = j.get <ns :: person>（）;

 

//就是

断言（p == p2）;

基本用法

要使与一种类型一起使用，只需提供两个功能：

使用 nlohmann :: json;

 

命名空间 ns {

     void  to_json（json＆j，const person＆p）{

        j = json {{ “ name ”，p。名称 }，{ “地址”，第 地址 }，{ “年龄”，第 年龄 }};

    }

 

    无效 from_json（const json＆j，person＆p）{

        j。在（“名称”）。get_to（第名）;

        j。在（“地址”）。get_to（第地址）;

        j。在（“年龄”）。get_to（第年龄）;

    }

} //名称空间ns

就这样！当json使用类型调用构造函数时，自定义to_json方法将被自动调用。同样，在调用get<your_type>()或时get_to(your_type&)，from_json将调用该方法。

一些重要的事情：

• 这些方法必须位于类型的名称空间（可以是全局名称空间）中，否则库将无法找到（在本示例中，位于定义的名称空间ns中person）。
• 在使用这些转换的任何地方，这些方法都必须可用（例如，必须包含适当的标头）。请查看问题1108，了解否则可能发生的错误。
• 使用时get<your_type>()，your_type 必须为DefaultConstructible。（有一种绕过此要求的方法，将在后面介绍。）
• 在函数中from_json，使用函数at()访问对象值而不是operator[]。万一键不存在，at将引发可以处理的异常，而operator[]表现出未定义的行为。
• 无需为STL类型添加序列化器或反序列化器，例如std::vector：该库已经实现了这些。

使用宏简化生活

如果只想对一些结构进行序列化/反序列化，则to_json/ from_json函数可能会很多。

只要（1）想要将JSON对象用作序列化和（2）要将成员变量名称用作该对象中的对象键，就有两个宏可以使生活更轻松：

• NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(name, member1, member2, ...) 将在要为其创建代码的类/结构的名称空间内定义。
• NLOHMANN_DEFINE_TYPE_INTRUSIVE(name, member1, member2, ...)在要为其创建代码的类/结构中定义。该宏还可以访问私有成员。

在两个宏中，第一个参数是类/结构的名称，其余所有参数都为成员命名。

例子

上面结构的to_json/ from_json函数person可以通过以下方式创建：

命名空间 ns {

     NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE（人，姓名，地址，年龄）

}

这是一个NLOHMANN_DEFINE_TYPE_INTRUSIVE需要私人成员的示例：

命名空间 ns {

     类 地址 {

       私有：

        std :: string street;

        INT housenumber;

        INT邮编;

       

      公开：

        NLOHMANN_DEFINE_TYPE_INTRUSIVE（地址，街道，门牌号，邮政编码）

    };

}

如何转换第三方类型？

这需要更高级的技术。但首先，让看看这种转换机制是如何工作的：

该库使用JSON序列化器将类型转换为json。默认的序列化器nlohmann::json为nlohmann::adl_serializer（ADL表示参数依赖查找）。

这样实现（简化）：

template < typename T>

 struct  adl_serializer {

     static  void  to_json（json＆j，const T＆value）{

         //在T的命名空间中调用“ to_json”方法

    }

 

    static  void  from_json（const json＆j，T＆value）{

         //相同，但使用“ from_json”方法

    }

};

当可以控制类型的名称空间时，此序列化程序可以正常工作。但是，关于boost::optional或std::filesystem::path（C ++ 17）呢？劫持boost名称空间是非常糟糕的，并且向模板添加模板专业化以外的内容是非法的std。

为了解决这个问题，需要adl_serializer在nlohmann名称空间中添加的特殊化，这是一个示例：

//部分专业化（也可以完全专业化）

名称空间 nlohmann {

    模板 <类型名 T>

     struct  adl_serializer <boost :: optional <T >> {

        静态 void  to_json（json＆j， const boost :: optional <T>＆opt）{

            如果（opt == boost :: none）{

                j = nullptr ;

            } 其 {

              j = * opt; //这将调用adl_serializer <T> :: to_json将

                        //发现T的命名空间中的自由函数to_json！

            }

        }

 

        静态 无效 from_json（const json＆j，boost :: optional <T>＆opt）{

             if（j。is_null（））{

                opt = boost :: none;

            } 其 {

                选择= j。得到 <T>（）; //与上述相同，但

                                  //使用 adl_serializer <T> :: from_json

            }

        }

    };

}

如何get()用于非默认的可构造/不可复制类型？

如果类型为MoveConstructible，则有一种方法。还需要专门化adl_serializer，但要有一个特殊的from_json重载：

struct  move_only_type {

     move_only_type（）= 删除 ;

    move_only_type（int ii）：i（ii）{}

     move_only_type（const move_only_type＆）= delete ;

    move_only_type（move_only_type &&）= 默认值；

 

    诠释 I;

};

 

名称空间 nlohmann {

     template <>

     struct  adl_serializer <move_only_type> {

         //注意：返回类型不再是'void'，该方法仅

        //使用一个参数

        static move_only_type from_json（const json＆j）{

             return {j。get < int >（）};

        }

 

        //这就是陷阱！必须提供to_json方法！否则

        //

        将//无法将move_only_type转换为json，因为完全//对该类型的adl_serializer进行了专门化//

         static  void  to_json（json＆j，move_only_type t）{

            j = t  ;

        }

    };

}

可以编写自己的序列化器吗？（高级使用）

是。可能需要看一下unit-udt.cpp测试套件，以查看一些示例。

如果编写自己的序列化器，则需要做一些事情：

• 使用不同的basic_json别名nlohmann::json（的最后一个模板参数basic_json是JSONSerializer）
• basic_json在所有to_json/ from_json方法中使用别名（或模板参数）
• 使用nlohmann::to_json以及nlohmann::from_json何时需要ADL

这是一个示例，没有简化，仅接受大小<= 32的类型，并使用ADL。

// //应该使用void作为第二个模板参数

// //如果不需要对T

template < typename T， typename SFINAE = typename std :: enable_if < sizeof（T）<= 32 > :: type进行编译时检查 >

 struct  less_than_32_serializer {

    模板 <类型名称BasicJsonType>

    静态 void  to_json（BasicJsonType＆j，T值）{

         //要使用ADL，并

        使用 nlohmann :: to_json调用正确的to_json重载；//这个方法由adl_serializer调用，

                                 //这就是

        to_json（j，value）发生魔术的地方；

    }

 

    template < typename BasicJsonType>

     静态 无效 from_json（const BasicJsonType＆j，T＆value）{

         //

        使用 nlohmann :: from_json进行相同操作；

        from_json（j，值）;

    }

};

重新实现序列化器时要非常小心，如果不注意，可能会导致堆栈溢出：

模板 < 类型名 T，无效 >

 结构 bad_serializer

{

    template < typename BasicJsonType>

     static  void  to_json（BasicJsonType＆j，const T＆value）{

       //这将调用BasicJsonType :: json_serializer <T> :: to_json（j，value）;

      //如果BasicJsonType :: json_serializer == bad_serializer ...糟糕！

      j =值；

    }

 

    template < typename BasicJsonType>

     static  void  to_json（const BasicJsonType＆j，T＆value）{

       //这将调用BasicJsonType :: json_serializer <T> :: from_json（j，value）;

      //如果BasicJsonType :: json_serializer == bad_serializer ...糟糕！

      值= j。模板 获取 <T>（）; //哎呀！

    }

};

专门进行枚举转换

默认情况下，枚举值以整数形式序列化为JSON。在某些情况下，这可能会导致不良行为。如果在将数据序列化为JSON之后对枚举进行了修改或重新排序，则较晚的反序列化JSON数据可能是未定义的或与原始预期值不同的枚举值。

可以更精确地指定给定枚举如何映射到JSON和从JSON映射，如下所示：

//示例枚举类型声明

枚举 TaskState {

    TS_STOPPED，

    TS_RUNNING，

    TS_COMPLETED，

    TS_INVALID = -1，

};

 

//将TaskState值作为字符串

NLOHMANN_JSON_SERIALIZE_ENUM 映射到JSON（TaskState，{

    {TS_INVALID，nullptr }，

    {TS_STOPPED，“已停止” }，

    {TS_RUNNING，“正在运行” }，

    {TS_COMPLETED，“已完成”），

}）

的NLOHMANN_JSON_SERIALIZE_ENUM()宏声明一组to_json()/ from_json()功能型TaskState，同时避免重复和样板序列化代码。

用法：

//以字符串形式枚举JSON

json j = TS_STOPPED;

断言（j == “ stopped ”）;

 

//枚举的json字符串

json j3 = “正在运行”；

断言（j3.get <TaskState>（）== TS_RUNNING）;

 

//要枚举的未定义json值（其中，上面的第一个地图项是默认值）

json jPi = 3.14 ;

断言（jPi.get <TaskState>（）== TS_INVALID）;

就像上面的任意类型转换一样，

• NLOHMANN_JSON_SERIALIZE_ENUM() 必须在枚举类型的名称空间（可以是全局名称空间）中声明，否则库将无法找到，并且将默认为整数序列化。
• 使用转换的任何地方都必须可用（例如，必须包含适当的标题）。

其要点：

• 使用时get<ENUM_TYPE>()，未定义的JSON值将默认为地图中指定的第一对。仔细选择该默认对。
• 如果在地图中多次指定枚举或JSON值，则在与JSON进行相互转换时，将从地图顶部的第一个匹配项返回。

二进制格式（BSON，CBOR，MessagePack和UBJSON）

尽管JSON是一种无处不在的数据格式，但不是一种非常紧凑的格式，适合通过网络进行数据交换。因此，该库支持  BSON（二进制JSON），CBOR（简明二进制对象表示形式），MessagePack和UBJSON（通用二进制JSON规范），以将JSON值有效地编码为字节向量并对该向量进行解码。

//创建一个JSON值

json j = R“（ {” compact“：true，” schema“：0} ）” _json;

 

//序列化为BSON

std :: vector <std :: uint8_t > v_bson = json :: to_bson（j）;

 

// 0x1B，0x00、0x00、0x00、0x08、0x63、0x6F，0x6D，0x70、0x61、0x63、0x74、0x00、0x01、0x10、0x73、0x63、0x68、0x65、0x6D，0x61、0x00、0x00 0x00、0x00、0x00

 

//往返

json j_from_bson = json :: from_bson（v_bson）;

 

//序列化为CBOR

std :: vector <std :: uint8_t > v_cbor = json :: to_cbor（j）;

 

// 0xA2、0x67、0x63、0x6F，0x6D，0x70、0x61、0x63、0x74、0xF5、0x66、0x73、0x63、0x68、0x65、0x6D，0x61、0x00

 

//往返

json j_from_cbor = json :: from_cbor（v_cbor）;

 

//序列化为MessagePack

std :: vector <std :: uint8_t > v_msgpack = json :: to_msgpack（j）;

 

// 0x82、0xA7、0x63、0x6F，0x6D，0x70、0x61、0x63、0x74、0xC3、0xA6、0x73、0x63、0x68、0x65、0x6D，0x61、0x00

 

//往返

json j_from_msgpack = json :: from_msgpack（v_msgpack）;

 

//序列化为UBJSON

std :: vector <std :: uint8_t > v_ubjson = json :: to_ubjson（j）;

 

// 0x7B，0x69、0x07、0x63、0x6F，0x6D，0x70、0x61、0x63、0x74、0x54、0x69、0x06、0x73、0x63、0x68、0x65、0x6D，0x61、0x69、0x00、0x7D

 

//往返

json j_from_ubjson = json :: from_ubjson（v_ubjson）;

该库还支持BSON，CBOR（字节字符串）和MessagePack（bin，ext，fixext）的二进制类型。默认存储std::vector<std::uint8_t>为在库外部进行处理。

// CBOR字节串与有效载荷为0xCAFE

的std ::矢量<性病:: uint8_t > V = {的0x42， 0xCA， 0xFE的 };

 

//读取值

json j = json :: from_cbor（v）;

 

// JSON值的类型为binary

j.is_binary（）; //正确

 

//获取对存储的二进制值的引用

auto＆binary = j.get_binary（）;

 

//二进制值没有子类型（CBOR没有二进制子类型）

binary.has_subtype（）; //错误

 

//访问std :: vector <std :: uint8_t>成员函数

binary.size（）; // 2

binary [ 0 ]; // 0xCA

binary [ 1 ]; // 0xFE

 

//将子类型设置为0x10

二进制。set_subtype（ 0x10）;

 

//序列化为MessagePack

auto cbor = json :: to_msgpack（j）; // 0xD5（fixext2），0x10、0xCA，0xFE

支持的编译器

尽管已经是2020年，但对C ++ 11的支持仍然很少。当前，已知以下编译器可以工作：

• GCC 4.8-10.1（可能以后）
• 铛3.4-10.0（可能以后）
• Apple Clang 9.1-12.0（可能更高）
• 英特尔C ++编译器17.0.2（可能更高）
• Microsoft Visual C ++ 2015 /构建工具14.0.25123.0（以及更高版本）
• Microsoft Visual C ++ 2017 /生成工具15.5.180.51428（以及更高版本）
• Microsoft Visual C ++ 2019 /生成工具16.3.1 + 1def00d3d（以及更高版本）

很乐意了解其编译器/版本。

请注意：

• GCC 4.8有一个错误57824）：多行原始字符串不能作为宏的参数。不要使用此编译器直接在宏中使用多行原始字符串。
• Android默认使用非常老的编译器和C ++库。要解决此问题，请将以下内容添加到中Application.mk。这将切换到LLVM C ++库，Clang编译器，并启用C ++ 11和其默认禁用的功能。

• APP_STL := c++_shared
• NDK_TOOLCHAIN_VERSION := clang3.6
• APP_CPPFLAGS += -frtti -fexceptions

该代码可使用Android NDK，修订版9-11（以及更高版本）和CrystaX的Android NDK版本10 成功编译。

• 对于在MinGW或Android SDK上运行的GCC 'to_string' is not a member of 'std'，可能会发生错误（或类似的for strtod或strtof）。注意，这不是代码问题，而是编译器本身的问题。在Android上，请参见上文以使用较新的环境进行构建。对于MinGW，请参考此站点和此讨论以获取有关如何修复此错误的信息。对于Android NDK的使用APP_STL := gnustl_static，请参考此讨论。
• #error指令拒绝不支持的GCC和Clang版本。可以通过定义关闭JSON_SKIP_UNSUPPORTED_COMPILER_CHECK。请注意，在这种情况下，不希望获得任何支持。

Travis，AppVeyor，GitHub Actions和CircleCI当前在持续集成中使用编译器