From accd42068d4859c17d85c254e113b9ae1825b3dd Mon Sep 17 00:00:00 2001 From: tom Date: Wed, 3 Jun 2026 23:24:12 +0200 Subject: [PATCH] initial commit --- .../index/Database.hpp.8FCB98D28FDBB0C0.idx | Bin 0 -> 11428 bytes .../index/abi_macros.hpp.A081707905C787A0.idx | Bin 0 -> 716 bytes .../adl_serializer.hpp.18B34C3825E9E70C.idx | Bin 0 -> 1232 bytes .../index/begin.hpp.40665B6167D09A3F.idx | Bin 0 -> 1078 bytes .../binary_reader.hpp.AA9A163A2B500C8D.idx | Bin 0 -> 30076 bytes .../binary_writer.hpp.D1B5AC5431C23CF1.idx | Bin 0 -> 26390 bytes ...iner_with_subtype.hpp.AD04B1C6B528D9F1.idx | Bin 0 -> 2178 bytes .../index/cpp_future.hpp.0DE0C7543547E12E.idx | Bin 0 -> 1568 bytes .../index/detected.hpp.6175C12B0E3CC099.idx | Bin 0 -> 2110 bytes .../clangd/index/end.hpp.FD5A2886BB0CCDC3.idx | Bin 0 -> 1074 bytes .../index/exceptions.hpp.4F789F2C75FF5772.idx | Bin 0 -> 4996 bytes .../index/from_json.hpp.7BA34913BC4566F0.idx | Bin 0 -> 10936 bytes .../index/hash.hpp.A8462897C92B81CD.idx | Bin 0 -> 1236 bytes .../index/hedley.hpp.463A3D3EA3B3D4E8.idx | Bin 0 -> 7814 bytes .../hedley_undef.hpp.74FDEFCA4C2303C1.idx | Bin 0 -> 206 bytes .../identity_tag.hpp.9F205D8B82EEDF5E.idx | Bin 0 -> 388 bytes .../input_adapters.hpp.022904D7456E6E69.idx | Bin 0 -> 12390 bytes ...internal_iterator.hpp.504B69A30997D02D.idx | Bin 0 -> 730 bytes .../index/is_sax.hpp.6161CE31BC787D86.idx | Bin 0 -> 3330 bytes .../index/iter_impl.hpp.1C724707D112ABF1.idx | Bin 0 -> 13118 bytes .../iteration_proxy.hpp.E3479441413331C4.idx | Bin 0 -> 6542 bytes .../iterator_traits.hpp.043B605EDEF08CD8.idx | Bin 0 -> 1678 bytes .../index/json.hpp.E04643ED2089871F.idx | Bin 0 -> 91492 bytes ...custom_base_class.hpp.6B3A4A4E00C191C7.idx | Bin 0 -> 770 bytes .../index/json_fwd.hpp.343912FD338DE2DF.idx | Bin 0 -> 852 bytes .../json_pointer.hpp.FB6E291D7A2902B3.idx | Bin 0 -> 11734 bytes .../index/json_ref.hpp.7D03FA6FA42B8F28.idx | Bin 0 -> 2082 bytes ..._reverse_iterator.hpp.29EDF7964BABE8B3.idx | Bin 0 -> 2318 bytes .../index/json_sax.hpp.D9EB17DA224343C8.idx | Bin 0 -> 13314 bytes .../index/lexer.hpp.CF0733DA6F175E1F.idx | Bin 0 -> 13706 bytes .../macro_scope.hpp.CD8D41BA56E1C328.idx | Bin 0 -> 3096 bytes .../macro_unscope.hpp.D4E087B7A41F3825.idx | Bin 0 -> 238 bytes .../index/main.cpp.3C0F98A0009F93CB.idx | Bin 0 -> 6334 bytes .../index/main.cpp.B306525CDF572C5F.idx | Bin 0 -> 6832 bytes .../index/main.cpp.B775D23AA44ADD8D.idx | Bin 0 -> 476 bytes .../ordered_map.hpp.0459B1FEA5C8FA57.idx | Bin 0 -> 6956 bytes .../output_adapters.hpp.758462CF90030177.idx | Bin 0 -> 3452 bytes .../index/parser.hpp.917EE895F45C94B2.idx | Bin 0 -> 7988 bytes .../index/position_t.hpp.89E0F348D620259C.idx | Bin 0 -> 758 bytes ...rimitive_iterator.hpp.78C60DACBF4B20D3.idx | Bin 0 -> 2454 bytes .../index/serializer.hpp.34499B757C5C4B4C.idx | Bin 0 -> 12906 bytes .../index/std_fs.hpp.BC781634FF7DA14A.idx | Bin 0 -> 426 bytes .../string_concat.hpp.3881C8510FCD56A8.idx | Bin 0 -> 3076 bytes .../string_escape.hpp.429D33996FBBADFB.idx | Bin 0 -> 934 bytes .../index/to_chars.hpp.BCD53D9DDCF8DC32.idx | Bin 0 -> 8542 bytes .../index/to_json.hpp.29AC21C047FF28B3.idx | Bin 0 -> 11478 bytes .../type_traits.hpp.5A839C4CB23F72A3.idx | Bin 0 -> 21562 bytes .../index/value_t.hpp.05988CCF4C034D74.idx | Bin 0 -> 1910 bytes .../index/void_t.hpp.43EA37E1B3A26608.idx | Bin 0 -> 600 bytes .gitignore | 2 + CMakeLists.txt | 55 + CSVToLatex/src/main.cpp | 6 + .../include/nlohmann/adl_serializer.hpp | 55 + .../nlohmann/byte_container_with_subtype.hpp | 103 + .../include/nlohmann/detail/abi_macros.hpp | 100 + .../nlohmann/detail/conversions/from_json.hpp | 497 + .../nlohmann/detail/conversions/to_chars.hpp | 1118 + .../nlohmann/detail/conversions/to_json.hpp | 446 + .../include/nlohmann/detail/exceptions.hpp | 257 + .../include/nlohmann/detail/hash.hpp | 129 + .../nlohmann/detail/input/binary_reader.hpp | 3009 ++ .../nlohmann/detail/input/input_adapters.hpp | 492 + .../nlohmann/detail/input/json_sax.hpp | 727 + .../include/nlohmann/detail/input/lexer.hpp | 1633 + .../include/nlohmann/detail/input/parser.hpp | 519 + .../nlohmann/detail/input/position_t.hpp | 37 + .../detail/iterators/internal_iterator.hpp | 35 + .../nlohmann/detail/iterators/iter_impl.hpp | 751 + .../detail/iterators/iteration_proxy.hpp | 242 + .../detail/iterators/iterator_traits.hpp | 61 + .../iterators/json_reverse_iterator.hpp | 130 + .../detail/iterators/primitive_iterator.hpp | 132 + .../detail/json_custom_base_class.hpp | 39 + .../include/nlohmann/detail/json_pointer.hpp | 988 + .../include/nlohmann/detail/json_ref.hpp | 78 + .../include/nlohmann/detail/macro_scope.hpp | 482 + .../include/nlohmann/detail/macro_unscope.hpp | 45 + .../nlohmann/detail/meta/call_std/begin.hpp | 17 + .../nlohmann/detail/meta/call_std/end.hpp | 17 + .../nlohmann/detail/meta/cpp_future.hpp | 171 + .../include/nlohmann/detail/meta/detected.hpp | 70 + .../nlohmann/detail/meta/identity_tag.hpp | 21 + .../include/nlohmann/detail/meta/is_sax.hpp | 159 + .../include/nlohmann/detail/meta/std_fs.hpp | 29 + .../nlohmann/detail/meta/type_traits.hpp | 795 + .../include/nlohmann/detail/meta/void_t.hpp | 24 + .../nlohmann/detail/output/binary_writer.hpp | 1838 ++ .../detail/output/output_adapters.hpp | 147 + .../nlohmann/detail/output/serializer.hpp | 988 + .../include/nlohmann/detail/string_concat.hpp | 146 + .../include/nlohmann/detail/string_escape.hpp | 72 + .../include/nlohmann/detail/value_t.hpp | 118 + .../All/jsonfmcpp/include/nlohmann/json.hpp | 5258 ++++ .../jsonfmcpp/include/nlohmann/json_fwd.hpp | 75 + .../include/nlohmann/ordered_map.hpp | 359 + .../nlohmann/thirdparty/hedley/hedley.hpp | 2045 ++ .../thirdparty/hedley/hedley_undef.hpp | 158 + .../single_include/nlohmann/json.hpp | 24765 ++++++++++++++++ .../single_include/nlohmann/json_fwd.hpp | 176 + .../lib/CMake/Linux/JSONlibConfig.cmake | 1 + DatabaseGenerator/src/Database.hpp | 246 + DatabaseGenerator/src/main.cpp | 262 + TradeOffsComparator/Rscripts/Corr.R | 294 + TradeOffsComparator/src/main.cpp | 243 + .../include/nlohmann/adl_serializer.hpp | 55 + .../nlohmann/byte_container_with_subtype.hpp | 103 + .../include/nlohmann/detail/abi_macros.hpp | 100 + .../nlohmann/detail/conversions/from_json.hpp | 497 + .../nlohmann/detail/conversions/to_chars.hpp | 1118 + .../nlohmann/detail/conversions/to_json.hpp | 446 + .../include/nlohmann/detail/exceptions.hpp | 257 + .../include/nlohmann/detail/hash.hpp | 129 + .../nlohmann/detail/input/binary_reader.hpp | 3009 ++ .../nlohmann/detail/input/input_adapters.hpp | 492 + .../nlohmann/detail/input/json_sax.hpp | 727 + .../include/nlohmann/detail/input/lexer.hpp | 1633 + .../include/nlohmann/detail/input/parser.hpp | 519 + .../nlohmann/detail/input/position_t.hpp | 37 + .../detail/iterators/internal_iterator.hpp | 35 + .../nlohmann/detail/iterators/iter_impl.hpp | 751 + .../detail/iterators/iteration_proxy.hpp | 242 + .../detail/iterators/iterator_traits.hpp | 61 + .../iterators/json_reverse_iterator.hpp | 130 + .../detail/iterators/primitive_iterator.hpp | 132 + .../detail/json_custom_base_class.hpp | 39 + .../include/nlohmann/detail/json_pointer.hpp | 988 + .../include/nlohmann/detail/json_ref.hpp | 78 + .../include/nlohmann/detail/macro_scope.hpp | 482 + .../include/nlohmann/detail/macro_unscope.hpp | 45 + .../nlohmann/detail/meta/call_std/begin.hpp | 17 + .../nlohmann/detail/meta/call_std/end.hpp | 17 + .../nlohmann/detail/meta/cpp_future.hpp | 171 + .../include/nlohmann/detail/meta/detected.hpp | 70 + .../nlohmann/detail/meta/identity_tag.hpp | 21 + .../include/nlohmann/detail/meta/is_sax.hpp | 159 + .../include/nlohmann/detail/meta/std_fs.hpp | 29 + .../nlohmann/detail/meta/type_traits.hpp | 795 + .../include/nlohmann/detail/meta/void_t.hpp | 24 + .../nlohmann/detail/output/binary_writer.hpp | 1838 ++ .../detail/output/output_adapters.hpp | 147 + .../nlohmann/detail/output/serializer.hpp | 988 + .../include/nlohmann/detail/string_concat.hpp | 146 + .../include/nlohmann/detail/string_escape.hpp | 72 + .../include/nlohmann/detail/value_t.hpp | 118 + lib/All/jsonfmcpp/include/nlohmann/json.hpp | 5258 ++++ .../jsonfmcpp/include/nlohmann/json_fwd.hpp | 75 + .../include/nlohmann/ordered_map.hpp | 359 + .../nlohmann/thirdparty/hedley/hedley.hpp | 2045 ++ .../thirdparty/hedley/hedley_undef.hpp | 158 + .../single_include/nlohmann/json.hpp | 24765 ++++++++++++++++ .../single_include/nlohmann/json_fwd.hpp | 176 + lib/CMake/Linux/JSONlibConfig.cmake | 1 + 152 files changed, 100216 insertions(+) create mode 100644 .cache/clangd/index/Database.hpp.8FCB98D28FDBB0C0.idx create mode 100644 .cache/clangd/index/abi_macros.hpp.A081707905C787A0.idx create mode 100644 .cache/clangd/index/adl_serializer.hpp.18B34C3825E9E70C.idx create mode 100644 .cache/clangd/index/begin.hpp.40665B6167D09A3F.idx create mode 100644 .cache/clangd/index/binary_reader.hpp.AA9A163A2B500C8D.idx create mode 100644 .cache/clangd/index/binary_writer.hpp.D1B5AC5431C23CF1.idx create mode 100644 .cache/clangd/index/byte_container_with_subtype.hpp.AD04B1C6B528D9F1.idx create mode 100644 .cache/clangd/index/cpp_future.hpp.0DE0C7543547E12E.idx create mode 100644 .cache/clangd/index/detected.hpp.6175C12B0E3CC099.idx create mode 100644 .cache/clangd/index/end.hpp.FD5A2886BB0CCDC3.idx create mode 100644 .cache/clangd/index/exceptions.hpp.4F789F2C75FF5772.idx create mode 100644 .cache/clangd/index/from_json.hpp.7BA34913BC4566F0.idx create mode 100644 .cache/clangd/index/hash.hpp.A8462897C92B81CD.idx create mode 100644 .cache/clangd/index/hedley.hpp.463A3D3EA3B3D4E8.idx create mode 100644 .cache/clangd/index/hedley_undef.hpp.74FDEFCA4C2303C1.idx create mode 100644 .cache/clangd/index/identity_tag.hpp.9F205D8B82EEDF5E.idx create mode 100644 .cache/clangd/index/input_adapters.hpp.022904D7456E6E69.idx create mode 100644 .cache/clangd/index/internal_iterator.hpp.504B69A30997D02D.idx create mode 100644 .cache/clangd/index/is_sax.hpp.6161CE31BC787D86.idx create mode 100644 .cache/clangd/index/iter_impl.hpp.1C724707D112ABF1.idx create mode 100644 .cache/clangd/index/iteration_proxy.hpp.E3479441413331C4.idx create mode 100644 .cache/clangd/index/iterator_traits.hpp.043B605EDEF08CD8.idx create mode 100644 .cache/clangd/index/json.hpp.E04643ED2089871F.idx create mode 100644 .cache/clangd/index/json_custom_base_class.hpp.6B3A4A4E00C191C7.idx create mode 100644 .cache/clangd/index/json_fwd.hpp.343912FD338DE2DF.idx create mode 100644 .cache/clangd/index/json_pointer.hpp.FB6E291D7A2902B3.idx create mode 100644 .cache/clangd/index/json_ref.hpp.7D03FA6FA42B8F28.idx create mode 100644 .cache/clangd/index/json_reverse_iterator.hpp.29EDF7964BABE8B3.idx create mode 100644 .cache/clangd/index/json_sax.hpp.D9EB17DA224343C8.idx create mode 100644 .cache/clangd/index/lexer.hpp.CF0733DA6F175E1F.idx create mode 100644 .cache/clangd/index/macro_scope.hpp.CD8D41BA56E1C328.idx create mode 100644 .cache/clangd/index/macro_unscope.hpp.D4E087B7A41F3825.idx create mode 100644 .cache/clangd/index/main.cpp.3C0F98A0009F93CB.idx create mode 100644 .cache/clangd/index/main.cpp.B306525CDF572C5F.idx create mode 100644 .cache/clangd/index/main.cpp.B775D23AA44ADD8D.idx create mode 100644 .cache/clangd/index/ordered_map.hpp.0459B1FEA5C8FA57.idx create mode 100644 .cache/clangd/index/output_adapters.hpp.758462CF90030177.idx create mode 100644 .cache/clangd/index/parser.hpp.917EE895F45C94B2.idx create mode 100644 .cache/clangd/index/position_t.hpp.89E0F348D620259C.idx create mode 100644 .cache/clangd/index/primitive_iterator.hpp.78C60DACBF4B20D3.idx create mode 100644 .cache/clangd/index/serializer.hpp.34499B757C5C4B4C.idx create mode 100644 .cache/clangd/index/std_fs.hpp.BC781634FF7DA14A.idx create mode 100644 .cache/clangd/index/string_concat.hpp.3881C8510FCD56A8.idx create mode 100644 .cache/clangd/index/string_escape.hpp.429D33996FBBADFB.idx create mode 100644 .cache/clangd/index/to_chars.hpp.BCD53D9DDCF8DC32.idx create mode 100644 .cache/clangd/index/to_json.hpp.29AC21C047FF28B3.idx create mode 100644 .cache/clangd/index/type_traits.hpp.5A839C4CB23F72A3.idx create mode 100644 .cache/clangd/index/value_t.hpp.05988CCF4C034D74.idx create mode 100644 .cache/clangd/index/void_t.hpp.43EA37E1B3A26608.idx create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 CSVToLatex/src/main.cpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/adl_serializer.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/byte_container_with_subtype.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/abi_macros.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/from_json.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_chars.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_json.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/exceptions.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/hash.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/binary_reader.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/input_adapters.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/json_sax.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/lexer.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/parser.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/position_t.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/internal_iterator.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iter_impl.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iteration_proxy.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iterator_traits.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/json_reverse_iterator.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/primitive_iterator.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_custom_base_class.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_pointer.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_ref.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_scope.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_unscope.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/begin.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/end.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/cpp_future.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/detected.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/identity_tag.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/is_sax.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/std_fs.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/type_traits.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/void_t.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/output/binary_writer.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/output/output_adapters.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/output/serializer.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/string_concat.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/string_escape.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/value_t.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/json.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/json_fwd.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/ordered_map.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/thirdparty/hedley/hedley.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/thirdparty/hedley/hedley_undef.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/single_include/nlohmann/json.hpp create mode 100644 DatabaseGenerator/lib/All/jsonfmcpp/single_include/nlohmann/json_fwd.hpp create mode 100755 DatabaseGenerator/lib/CMake/Linux/JSONlibConfig.cmake create mode 100644 DatabaseGenerator/src/Database.hpp create mode 100644 DatabaseGenerator/src/main.cpp create mode 100644 TradeOffsComparator/Rscripts/Corr.R create mode 100644 TradeOffsComparator/src/main.cpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/adl_serializer.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/byte_container_with_subtype.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/abi_macros.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/conversions/from_json.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_chars.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_json.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/exceptions.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/hash.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/input/binary_reader.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/input/input_adapters.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/input/json_sax.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/input/lexer.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/input/parser.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/input/position_t.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/iterators/internal_iterator.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iter_impl.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iteration_proxy.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iterator_traits.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/iterators/json_reverse_iterator.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/iterators/primitive_iterator.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/json_custom_base_class.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/json_pointer.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/json_ref.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/macro_scope.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/macro_unscope.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/begin.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/end.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/cpp_future.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/detected.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/identity_tag.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/is_sax.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/std_fs.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/type_traits.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/meta/void_t.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/output/binary_writer.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/output/output_adapters.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/output/serializer.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/string_concat.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/string_escape.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/detail/value_t.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/json.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/json_fwd.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/ordered_map.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/thirdparty/hedley/hedley.hpp create mode 100644 lib/All/jsonfmcpp/include/nlohmann/thirdparty/hedley/hedley_undef.hpp create mode 100644 lib/All/jsonfmcpp/single_include/nlohmann/json.hpp create mode 100644 lib/All/jsonfmcpp/single_include/nlohmann/json_fwd.hpp create mode 100755 lib/CMake/Linux/JSONlibConfig.cmake diff --git a/.cache/clangd/index/Database.hpp.8FCB98D28FDBB0C0.idx b/.cache/clangd/index/Database.hpp.8FCB98D28FDBB0C0.idx new file mode 100644 index 0000000000000000000000000000000000000000..e3ea50881c1b00a71ff6b4481eb03af51fe16849 GIT binary patch literal 11428 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/abi_macros.hpp.A081707905C787A0.idx b/.cache/clangd/index/abi_macros.hpp.A081707905C787A0.idx new file mode 100644 index 0000000000000000000000000000000000000000..1f1233f81de14c7f8acf3f40752ced651ba1a909 GIT binary patch literal 716 zcmWIYbaOkx#K7R3;#rZKT9U}Zz`!63#Kk2=nGHaCCJ9n5FHw>(H}Otw_F#BM+ZG6I^Goh23Hg+5LG-&M?xB?SCdE68Kx-W-)}+JIxab&Z~{jH+yN69 z<2ZUm9TkAWVH{zqFx9PR%@)-;FHivrJ99Xz!-Nz1tJtC^UUC9DK$1sN1}4nIsKBBi z0^?obS-wpA;WiJTUQrHFxJ?}Mzupp#-BJ$}HsUaX+vNGQxZXlzYAeu4T^?PyFL)Ro zSRB+~MyBp6TcaU+u^XsYj6)1=WNP;FJ$K^6Rse-fIZWkXs_#!cb$Z{v$E$(D-W=X= zL!_c>g;U&)ZvYA#au{mBR3CcLX6;!1?>SJ|pTi#%r(kfP%kAyEZ?k>@g_U`fbz#E( sLX~lOqVfNL!qyzthA?4c0+4E$V-J2To zc=gxk-<~|QEVy>rXXW}+tP}H7{}ma{JX^`>kooX=WTwK>Cz%gb5AmxXAW@Xtik9YsJ-hO@d>+#!H+fOeGE7SjQ_CVt*RUaYFHBxJj z{%32qe!H|H)(fqkMLEG|1S+^!3p~i4W^zQ< zQeEE5e?pUwU~rRj-%*qE|NED!JM%R}zf-E3S|ef+cd7hR%zD$q3xsyZp1e45rVM}h z8sQJ`{5RT`wmoJHJ-KWBm-Y8zt};H)UntQ&>)xCG9hG^zWB#e~-_Pd#d$Zy*x1Z+> zC5Gb4+@v~S=%;*HkC%Z}Pe4x`OfYZ&<$ypn*5c^AzoN}TOx!?e6#*4V zFaeV`v{Kr#P37bvh_sY|lq4&NfJxW(Ub87v<-Nnk#KObCD#|V@3MLphnVEnQ&dADI zl$ur?&4h3TBNy0qn7)XAzXe_Exa1glSj`yBq#;gXV3@!d$I&C|r~nieWDt~v3A;@_ z*C1FtRfm~}RbN(L1?DpzRs$IWWdzSi#7G*(Q@VO^O_cK0AfOgiZ`E*^Z+TeN{M4cl zJPlusNEq*^+r=XnZU-cB@~}$lNE^dKfQMB^TgC{%lT(({Lhw{IRP|v701ekxGeYn* zv@{G6Jbhh#6PW9OF4r+IM(~VOjI?1qm=0iwfno&~VlXR#!k~zN3BzchFenzxA1NnR zWl!21CVujz~uHfW@F;xX5i#w;FAXv47@DNKv_mkR`;nhPk(%7&M(Ep$^#Su0!}^!K2-)z zFdL}geQ#QDR_p;GZYEyrCTz>}=kt5|a6S(MD>qmZ%mgMz1~zt}2^Zh|l9K7FKg!0y zhH3)LiZ@D~l9D`+F9IFOh1HR4E?ax~bZTw^-N1uY0Yg!0TJe2g+>3tcR=7UxB|9Sz z*c;7a`qEDx%yfbU0}~V2`}c&;F@52wUBv?C!K{Y`1tTYlURVGyqUxPj9zVsS?~V{u z7-mDnzu$tcbzE{l2M90-NJ9dIfnfq;97m6+qXJNvhk-{HCj8s&#P6jur)x1nTmm!G zbkZ%?YvB{!(R>lU*m!HQs9GqR@O`;+CxrwGOF+WF2!@#rix(z{cVK>o1Pshm2Rc1- z8ReS}q8SN`GOXbRGg#w%)@;!gEf>-B!h#bTFy@bx6RWZ(ZJyaF7qRi>>dR2C!lD#L zLsi2f?3Lr0o2zVBmlS H1_J{CPDV_| literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/binary_reader.hpp.AA9A163A2B500C8D.idx b/.cache/clangd/index/binary_reader.hpp.AA9A163A2B500C8D.idx new file mode 100644 index 0000000000000000000000000000000000000000..e96baca231d85ab2a6c1de44e21dd398027a3ff8 GIT binary patch literal 30076 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 D9OSP{ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/binary_writer.hpp.D1B5AC5431C23CF1.idx b/.cache/clangd/index/binary_writer.hpp.D1B5AC5431C23CF1.idx new file mode 100644 index 0000000000000000000000000000000000000000..3ae6965fe3ae619f3f50db97dfe45918cc618e7b GIT binary patch literal 26390 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/byte_container_with_subtype.hpp.AD04B1C6B528D9F1.idx b/.cache/clangd/index/byte_container_with_subtype.hpp.AD04B1C6B528D9F1.idx new file mode 100644 index 0000000000000000000000000000000000000000..0fd3d07dc38df3dcc6d49c507c83cc47c7a55ccd GIT binary patch literal 2178 zcmbVMeNa?Y6o31C%H78Uc3pN^R@i0NdN8f5xa{5*$cF+8m?9%Ao4};a zphcKXVNlla;Z&9xm4IgHG^q>_+Nd~&RDg{&m0EmBpElBck2ziZ*Eh4jedqk%z31F> zf9I@ANldIm6qVpgso7RiUC2-rrNBRTb=6bx5{fb|qNtkIzID#DMXO|EJzp5=3+$Ow z-N*Wd>y!NIHkS7ER9H6h3YUED)Q#6Z`tZv?!k8KU_V`q(x$pW-cR|(U;9L5xwW@@< z*4~e^y8im1Hf!|jxV6ShY{?t-j_{{f51kCjxDs~lu>AKB_0oVHa>u~0#nLHFTU*X= zw%x-QI7!`N&&AA?vcQ%@89T!!jvTnzrrz85V`fEVdCr!z5l4102_p|VzX_~1eOFkv z>6XjviaA@nInOg0f7q59=g6LH{Jybi$NGwC-ut%QGd|bR^?dh(KI=a?caSr+kEE>Hx3qR=&!E>&CqkA-)#@({Mb|oi zPHt?;9t{ZYpT4@rqY1ur#*?Ex(>PSxe*4b*d8VXK^HfbWEB?7PzVcjDyD>b?UAwJl z23K-=`^;o}Z^I%Py+lr-TxqUK1PT{lc)AbPC!YVz2dU`AnC2N?Cj!uGH)MtN$@i*d zv;x!7(rCE|Kr>~wqjgs+ANHmFFkK`s(ue@GzHDZHfA_ImU)mSb#nNJx2te=A9doXk z?S00ZR$)4j4OEE$^q*N{o64KG-7;E-5LjnN(SXXC#!~@U0Eu($#>P$tZRs^8E zvsO>PJ9z%GjP}R0L+bDs0qD+vs8{!BU03Ee4`PCJNC2Q;$aXVtT7S9bMKdxADVHeq zB2ZFVf@Lp3i(l{Pb5E>mnx0>;XY@KG0IZLy{=E9)-I`f%+6zZlvud>nKv$KNx-a8~ zf}5AH;*CSp%^iJ5Th%It;Sj%pF8~2>C{!D2AeOn(?13V2C{i0~01Lj6(4tgeUyurR z3pxS!`nz}Jj$N!)!l6>CblJS>DC!kS0otdG3&Cy~B?|^O2num1oDEmN9dpRSS`?4~ zhis47k|7?4>~Z!~VkMy@IouD2(sk)!AS4duqkK7(g%za=X@XRx95S({020{BS_2jY zPPIKrLfJFy`NT>_$;t(R{nCR-;B3F_AkY+t3Q&QPq#^VLq;cBU)-xJ$$VKBb`r87? z=5~Mk{}%L(7c2G)tmTj~#^@lKn=R%?N#+ivLr=1E`Z_fvyY#5^1Y#92MKZVt@L~-K z4G5ti2)=8f=fDj;huuQMfg6&*ZlTA(4fVi#3k?SD_|qp1Re=qk+_ydhpEwaSecf&Fllfqq9?6wOpQUT^4v?VJe`PqT+;|%M~NhxpeQxr#DS@QZHJ-M-o literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/cpp_future.hpp.0DE0C7543547E12E.idx b/.cache/clangd/index/cpp_future.hpp.0DE0C7543547E12E.idx new file mode 100644 index 0000000000000000000000000000000000000000..08870a5d0491767fd56d9e7503c7a9f1505f6a25 GIT binary patch literal 1568 zcmWIYbaRtnV_zoNW)_hYrK z#|`V1qo%VbTt0p1ob|jXO%Ju*GBsH}1+34kKW6S7X#LJ6E8Ud)wT+qAN;}q&IZeAf zm$CHBxvHKud7q!luH#O6n}3G|)TTYKG&4W2p}9xiK#5WP)-Sz@kL^;P-u27f8y;WO zWi}%*Ku;<@D&*pFJBOZCu58ak8Js=SC$q(TJ^bPS^OfzZ7;?GAt>&#vsd_R~eER#> zL9ffXIufi{jb`2!d#icl&;41PGS7oAwEK(cZTsPzz9z|~**_>(xHBMj0e|qj!|FZv zg-p&mHZQAOHYI&#ubF1rx`xI(Yu+xAwEFlx*7w%3oAza;zk|}g3r}8Kc6WFAPQmk* zK?VJn)ZSk%7vIhP-Rg`GN9vlr?q4RiY~(YN-hL}KE{Vt)i9u~JNSmFczFe$8e z>MgF!O^O1>(`)}Nm4%~pR#ib()whAg+NB*H%`JO6GJZ-~7m#Uu<Os7fF6b9&Ygv@d%jf7r8m}>CAc{3=&ol*Mtd2{QE8FTE`^^ z6kf&1u!>O{5}3dY#TduYBkHICln`PNl7$JU{Jv%q;1~@Op2x^Bk5L>Z(Yva|eUbAe zC7^^PyQCOQ7#81*T+mo<7Sor0@?fTu_JOR^g_1pHK=q)&f(b`oUTb%K)uAw;u(*Y| z2h5pA-7X%va62FgD7=i(VHu-4ERnd_{Sf8uXsZHB%w_~4d6>m81we}-NeE^GEafnA zf>R7k7?xg`xS**7Ccy*bYfoV`hbe%i8KA+C1OrnDb1P5+lt^I0u+#yx580!zGyzl% zNf0n|&F{Rg^-S#F3-l2v1;C8?_sZGrP~p_WKw(h4!-Qe!25366>Wae;pH#72Jj=ub z^u5>;Mrl}ZfWl8;8KWqS4@*`+{m90yzq#m~(#;k3fVP3M70kA{NXD+dNmsrBg~ffv z17SX{5ofNQ$@~u_j2b&dsX2*)z!-sr9fDC@lw9l%iYsnsW}btKcGXT{<>BSy=VIW4 TMIZwMFM`RBVDccCTnHurEd}gm literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/detected.hpp.6175C12B0E3CC099.idx b/.cache/clangd/index/detected.hpp.6175C12B0E3CC099.idx new file mode 100644 index 0000000000000000000000000000000000000000..a0d8255fec57e63269d39bc4195c0cf53c85e957 GIT binary patch literal 2110 zcmYjQ2~bm46n*&#AMz8z50UH$$l3@7;{>B|m08ALvMLGk{hhX{g~e&j%}oYb$(ln~S2QO@Z8zog z2H*WR^GR9u>pbtTPYi1Om)HGP6tz3!W(_y!uaJQYJ!e#J3>p3v*JG0pd@+!dJ%^tE z=I{#hQ0Y3-SU`5>R{1>*K2=`wSx{Pl>oJq(k+}8g%}YW|eQUc+Ia6$-6-A)fa&R0v9s%||>?baj~hFq)AH-50X zd|Fab_NDjkrCr;iJ^RzQ$8Ypn^@$UIjH^|-%ovw?bku{@hZmIAOKYUHC+O3<+@^-j zvpJPi)r(CR>gyW&&2w*=?^zGFpPw4@{l2x7$F^z69Ju?@8K3LR#ysUpbEP^%a&=@- zu%voxXmQ;5y3co=RDBcn>XdE&f%^E=mrD1`M=oygu${GTi0MsHwNKpDvuI*L;icOt zLwA>mRjLo4=gXbW-T3`aU7+d3%++Y^ugr6r;rC5*R?!xRkxK% zYfGa$OD2aXmZ@ZfrwY+h zp45Q_gvG#olFWhlq2#Up0>Vv>=x{RJodv|F7>RIbhr#HU!6SPsH3CA46O5!$#scE= zxx)#?)4LL=zRJl`LX8{9d2%5O&_G>xykic}Fh@X)Rv_Ak@)5BB$E|;C+p68XB|$)p z!sWH3R?Gt83$P-Y{W!H9kSG(OEvZkb64;cVwwRsek{4X@XITjXAF0e z4sZ-`VF8ZU3nH%RSCl*x5YBkCP%>1)!pLfKGBPcBSSX-E4l%4g`)R&4jc*QXc~v1hL{IMyb$ANb8h3UyunTb17D+BT2^b z#!%pjo694{Ky%D4 q8Ou|}*gwD+!P1c>=Oc?Z<1FUb{<*>*gyy$iPrB=jeoud4~)H+WufTOP0Te12*199^-{(Ae;# z%HvaS^l<;{keG7(=Eq&4v*%wAdy#g}Zu`N&_n{oD`ZJqC=1$Gej=WwJtJJ(^O?3vp zE}L@XT-TXNk0zJiU~ur4Ydm>)-j@f41#Qz)JnVwJHXT>IdFETGgT;nN6Til7d=+v` zoo9wf@U5N3s;Bp!e~`m&{XF4{Wu>h0jRkiT1k}QRTw_{aqBPUgbkTsUPp z^QJ@Q%QVwi)3f?}#DBYoEo!MO(0QqHeB1rZ0yn?=_ZI2LG;BW1P+Xat^c)xt?o3DG zen}h=;%4IIVc_Ir;FAXv47@DNKv_mkR{4~dcRm;jxJogx@c>1DfRj&wPnm%e%mymx z&%6+QYU5ompb6YqO;9*B|GbE+T{I5^8#h=J%mgMz26k4U368hi{nm7M7qKz0qnZG- z;?7KI@2T>A``MWIP!+%&*{jt5^~J{Bhky#Wu)2YvC^fD4J}}N<{$*qW`?Fb0U;4>| znNAV^eha$Ramg|Aa0)O8NJE^-z%YR^j-yA^Q2{8-!@wg86V|aQ{FA$Jz5>(`nDc(S zo%p?U=5#Ga7O>ecRj?3b@m*I8bUY}=VD{dZJ9kn@ps)la42*7=pR&25zFe_$ZAMdVDQBhK zw#ac2n(%CECH|R~Zrjj=VIhIlU9d=k(NK?@KT=Mt%AT}&W~W@l#+R!vLqiW1QK3rC z@?F~%?xNXbu~|_zHl_VHnlLb)a}ouCeuBA#0cIORaZz%yILNo0YFolK6yLV|!pOnE J0rNfs0|1yLQg;9V literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/exceptions.hpp.4F789F2C75FF5772.idx b/.cache/clangd/index/exceptions.hpp.4F789F2C75FF5772.idx new file mode 100644 index 0000000000000000000000000000000000000000..d050c6e5cf2ffdcd45cb02c42826139379c47c64 GIT binary patch literal 4996 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/from_json.hpp.7BA34913BC4566F0.idx b/.cache/clangd/index/from_json.hpp.7BA34913BC4566F0.idx new file mode 100644 index 0000000000000000000000000000000000000000..71b1fec24f23a35aa3e19ee3755487dfd0538ab0 GIT binary patch literal 10936 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 g2ZxLe{UR*fdz6pwXg~ikOb{jXrQLAa^{3tc0Z z=wTCBm!EHU*mjpoX>EE&ZvV;bjc*){OqvW>iufl;2exgCHL&MlZJL?9W$$9%8V|>! z>_-l~PgYH9pV@FcNPb1b*_t1{HWBkH1GD|&x>^oaHy!Ltes*@QYsyWb#3up2pTscd zfBtca;TNM@iJ|wz7rwFismB_GW0JP~vf8v?`&I4C(%lg~=a=YO{qA_0@U^VOhi zxkW3tH>$AKKUg4>9KP4G(kk2Zw}yU7-1~X{*RQJ1%aC6w+~IP#m|5NbxqEK#hW+U$ zx%D}vEN)dteLWL+P5Xt3|K6`5FTVwEUGM&SMW~nLJP%I)S6!vEiWUUkZE4*7UB)S0 zgH`%yo&S$qXf1lbcYV7(nXT9E>VAWHFmp-pqb6t;j$)056 zh2OIj9AArk+crCZy-(Ws{QozIsplz%C%%uR9v#-{OU=IEB6Dh@mh`~nPI z8ax^TV1j{@g^5v+oso<6R*g_^;8&klJPaH_1!BTtQec9Cla-kbte_}0t=OB1fg$4G zZ$Z~OE;&XXt_DVi21aS1>0mH{F^;20)KLK_A;=&o3lm0(rJp>Q>BPfjuWGLeljPy@RP}`OT+i#>;CQ6g$;87IrVyrrP?WEb59hh< zX?>UTCT%_&50@B^m=N4sTw)4hYDhdIF$)AwgH?kYVVu6YzAl1SXjEtc!;yHg!m&uaWZ`5aUZ!v+5-(3856OlC;Q}PNLg7LrUWs@K+;*Gk)hkbw zT>Zkz!)2>ttATKSfIsy7&RCuNa4{<{4<9Et11C&^fq@UfATY5$S`hRWaB5rZ?IcBMXrUdN8I%U}L!edmW~zu45% z`N+_j|B48x?e5%mxT)*kKlPgO4V<@z3`ktv2IdE^z7`3$(*HQ}W!UVx z&3zs=wq@-c;~xFBV}k4LiS>i4y6m~(@*DYSkEg!-`ZMPVp93E?dWY>SiRyIg=sc}u z-_T`VGv<8dCx_rQ{o_w&9D2;l>wzyu$DTjDN7J~rO5iFXhyK5xpBJ~Bj;tT4>s&hz zcpkcY2-MPD-svt?a71;#Uzabh*JTU-i2kUEwuC?B?*A5EAh`BBKk;Bbluzk^g*s&)bOJAq=!K5tYMrry4kqIgc7?&)IvFga@7NB^99To z1jh(HMm%oU&lZqP`SSwKQyhtUB$Dzu2sudFyN__6;sy&EEX8N_pW4G6I`)B%T-&eX ze!ail@o5828$E5jg24(#a1k?#STCC|W>8G|aBhTi!f)WPfs^`y!UzuLE`C$u^r@pOb*v^PY16MWnoj#FIk4fPaX@`g(k zUoqi|N$OuW;X1`FE@*KPzRd+~6o9=4Gs>ud%NdkY0dL~Q zCMw`a4v|#Ai-ob63UG;lB~*YrgkuL4@J^xcqyjDwMggr~D4>wmzaZcO#j)s!rGnmy z`c^9FA~cGqpo=Xy7*clYr`;6>lT z!#5`4KuO$p@%t{-!{S}e@ZPS8gCudz#n0Kq{`Y>Jp0;ZLU>~ln({Y_Xz|$0JRR&ZU z#HdP`QNsRW^Q8<*sg4^=)?likptg}48#yT-!6Aa`dXX>|3Bm^n2%@^&E*#sb4&#I# zM}wUwj67ODUqC*se^J0iilfmHZR--X7}R6z#X+qAjRGX&DMTo=b^X_e)+`O(oHJNP zuz>Rdu1@iQ4ObrSI-d`b#7#H5>3+%+p+o)8>E8`2ZYL(-1m)LZU+0LBVTYcTpF6Y8 zPk2h77!eovg4pt${9Nh8N~cm$b$$2SMME>&iA2Ce=}YoNk4WoXFY9Yd4;CYz3Mc8GAkymUk+Gh;o+GqHgS{KxQf<8aNXwP_13t$ky)TTr2s0l|+ zf|~?134-%ndYV-zeUOj&1Y=*^c^lYMUi!l+c}8icm^->H^DLV3CCjv{;}; z=6lwHvzD^;%DSYK;e)$RkQTQH_#&F9Co@Q9$|PlO#vqU4s|>DE9B)FrNy-Os2(WD& zwY419QhblYJ&GfR9w|sxk|rQckoLk+4@bghAY>rn?;zZvc)bPdEy8cNU^~T!EI34Q zs2f86KkI?LHh!|tPcz4K`FeufnsElk83R31^&L|4pgFV8L`f{MaEYaSBY4`h?DOL? z-jPIzfgy%kgS5jv|NimXE+0r@g@G#!wOGY(ho0Z}&W#UTTsx@YK~1@t^ke831Fw7f zL@fdOB~aX8K!ZVc^-=~)8NsKSahmP|e*ykfwOfR~g>KhO0hyG)ER4%kr4gt{Alcs8 z2-#G%e<1upaie84+Nx`svwnTy>;qF|-cxR3xv4A^wK@~)D867?7fdyg-=ITT;_CPP zWa!ciOf!_l`o&*dxh?eGSF**|@HJH)wedKfptBA<>rnXdHeXnl>;Ii>?Vt+}y3{ag zUOk~t7#%cI5Z#4^O zrg$Uj8|j@j3n7d8(mjNG6o*<6YLW5OT2M=IrpuY>Qa*%Qk{goj1EGKXl;+uk`puFn zP~hSP_R<7DaGrhtd;BbUmhR&n_ED!!bQof;YK!)3*Hm zH9H?_j!2y&yJ}_F%AWA-vR?Bi{^hyT&wek7TsP+0gWD7S#;kzP zJ)8Xav~3F_B+-d=QYXpHidUdDv%@C&`Hq|2vCH51xYs8oV+*3?P_7wxji&pTO|Q%L zjr!J%s-%aPUyYXL6XC!J2XTdZ1L~V2cK|SfR(-?{lb~5O9L>QK(1RuWzX3BIKg# z|BK+#)nikF<7A8~04wa&Hs~L}7L`Q)5hoMV0>A>AKct$@RGJSIm_~uA9$-*QT4 zr_XrdCrLcdo>!s0a;Nk5$yp2AKj(3tXIo;^mXMx4ZE43;p0 zZ!ow)aUh34`ZO8BA%x-p0Rhy;qlF$#pDMEiWKsT{fO8aYLVXi`syu;kg4%o=LL0^P z7S!8Ml}3-35|>49Ns$pa=H|!TN-&i!{~kk5ok@8>x|9Q}>_;NhRx?;l6Z8}YDHK;R zsG|5LgPRo3H(@@#;FOtAMsW;>7~9>Y(z$+ut21A|tO!_16Y_mR-$zrOaslO(zb4=s z#XC{oNmHAX2q$Sm9%Mm~r7l#cg;@|r@eT`iP<+^e!xT4L&}?JZ%XjdJ`Ztfu2=`@u zRdQJ|`rB9iXEvotZwfRpkY0!uF=G)^1=s#)c@>BFq|5qGv!~T|3iR!kw7o9B{qtpS zyzD*9Bi-YrE&aVpre??t=dJ_q+7F|sl^IY*r5nT`h)VScgCi8@Gsvg-8iQ*T7n)E= zU*YF-m`|m>j>9^Nv$>wl)!~I&8;3T^M+rTONC-{wGHLxDI(zJb4D@(SxnkgjV~hBX<0P=?}d;EKjzOsbQw3o^J-Y?_B-m zn-TfIwcmC8T~}8a)aneVqkn5DHKFwX9tJFEvQ(BfF=5ESC1X=cWe>TW=i2F;(Q+d^ z`rq$X$}zTB*kYS5YFk|$x4M*{zq$CmXJ&lsI3rs~wlLXJMCU=Ri=L~^YbQpsk?KtD zzaXZeV8rSw`FRb)HTE0E@=e7#>vpwN$)}Ia8g8bhU12~4RsJ#t%czpiFgQbTkqJdq z*?Wb)mnySNKp9oyuL6FxaSxw}?2yy*YUBtToY-K$T@^g^$9S(PU27##=)^*&n(Dxb z%O2|O?AuP%FsxxpOJjnKjT_hx^^yoOF~}a%)Z0T&9d|r;)|+d~9k`rs^FZhw2(Nnl z0JW0_oTQU)W6(w?dquz%d+@03LVXwARuu>p_BL8nIIAsqP3ML9!6}NPIYd+cUm;)x_3wD0$5X#A6;Mj~9jNc1 z{$7qyZu|SD3sb@G^NLGy{Hp+0fl~giyTMj`-u}yySZVQ_w%E_xg?MnwUH8zWf|+VYsD^XZaW0FF$Nw;u+IFnjzZ%qfP$& NqYuxXzH51T{TJj!29p2) literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/hedley_undef.hpp.74FDEFCA4C2303C1.idx b/.cache/clangd/index/hedley_undef.hpp.74FDEFCA4C2303C1.idx new file mode 100644 index 0000000000000000000000000000000000000000..7d1b76a4751bbc74ac7f09f489aeccf00749f07a GIT binary patch literal 206 zcmWIYbaOk#z`)>~;#rZKT9U{DWD5gvaY<2T6Of(@#1(T)j~VhEGT>o2u#e+?j;Kcu zkIjN2VR328vVu8{_m$a}?S3k-)R1YA`umb9xZxYfTYGyVKghl<9<9D8P6EB0K=cwHq~b;Y8c32Qe@Qs#besQBQOt7SX4 z*6$C_W88C(?dJWo<8NPIy|45~%dpPcu#Nv0XRmW{Wp0up&@W0?53Y$)z8b{F#Kz9R zDkvqW1|}FdnHZTF7#LYu8H!TVid}&!BmVssbgko(W8`5KVGxl9ih#ic#yE~1QAY)! zFb@NdEKC??E+ZG%yk;?d=_e0nIsr|~Nd&1WE=n#I2Qff_3k9sAo-B5oco-HlvM>Mu De2$AM literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/input_adapters.hpp.022904D7456E6E69.idx b/.cache/clangd/index/input_adapters.hpp.022904D7456E6E69.idx new file mode 100644 index 0000000000000000000000000000000000000000..dfec2c66f6de5ff274d34f8d59d99fe4fce58af0 GIT binary patch literal 12390 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 O&rtqzAphyhfBqlGGQrUR literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/internal_iterator.hpp.504B69A30997D02D.idx b/.cache/clangd/index/internal_iterator.hpp.504B69A30997D02D.idx new file mode 100644 index 0000000000000000000000000000000000000000..2b149cfdc3ffdc0842be87e6d832680adea4a203 GIT binary patch literal 730 zcmWIYbaT7J#K7R3;#rZKT9U}Zz`!63#Kk2=nPH3!44%vk3>9fF#3p6c z0<{LkC(}iNh2&MeX%6duEz5O#R>d)u!);x1$t~8l71r-kV>J?0b_AG}ukEUSyJvps^8NnjtWu7BP1;_%{Y#_C`5wzj zg1x)XtaH7)WLC7?r=)o^#g$FJh5iXvE>_o=eJgg+f}>vHQ?|uDPn;ULGuiZDbn&_c z(oa%LmP*Wz$zZO{H=eM7pKWctOUazqB|1;f7nYT;Ty?=H@rTt_`^VaE7K{J)v1k0g zVfS3u`}wxN{!PDj&pb5sw};=p-fzOY`8k4YUKdy9Ce;B$IU&rB``32P06r!jE(SI^ zNjYsW!N38O1A=c+USGVjCs*?^aRa5L^rh^;1WejRprh`zt8yJ56AMsUMo-2DOu(e= z7q7b;n^o|NjfsPkflXXP+!9PMa56IiBbJekwJ0^Mcp=c5h=0EYUF*2y70}$bm57M|HWgCe8VD zA8585i<|_^OqeuKHORfqV*1ig9?W!NC`!#q1leC)lw7O~Vz7b;2w;aX7#P?tv29+s MGG9WEiItrJ03ZMUV*mgE literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/is_sax.hpp.6161CE31BC787D86.idx b/.cache/clangd/index/is_sax.hpp.6161CE31BC787D86.idx new file mode 100644 index 0000000000000000000000000000000000000000..c71822677988be31b861212e3a7e580be5c79ef5 GIT binary patch literal 3330 zcmYjS3se;66`mP&nB5r^24VSkf#qRVSsu$vScP4liy=WlP&BY0Z%`2AQADez5NJ>g zqLd@}!p3NAQ%_6f#9**ej@lT5r9OgKQ4_6IQ-f%XfN9fz#$IOToc+#z|Gjtao&Uf0 z`%@C)L zZk)0m?4EP_%icS)zYB4mG_?JGZB*Hj)Svx&PxwbcePK-5!`QuVyVw7xWTakgtmbt~z1C&~1pT;Cb>eBx&AVRQ1qEbGcH<4^Ne+_i>hec1S*-M8Db?Vn@oqbH*0nub4cF*$aeVS*mZ>=h1JV?(4Jdgoy>C@J9XMs z?Qrh$)fwXfp1M!ZG`H~!4##;$zLnm-bW4Ow`b2F+&u~E9hG#a3=k6PNw`@O4RBc+H zTR(#!T87{K_D+$WV5xZ?1X9r|M-d2x9fQxFM6((%pMR#jcb;Y`y%&MXmE{@{2*He> zgof)OE*qa?vp0_Sq&?k5AQW?KuocJOZXF4k`0Y#uO=+=1u}!gy2!uj`drEK^2upeT z!#oqmQvTRMPwQ185Q^Ej;RJ`yG3wGtj=v*IE$}2zk}^px0#q>P-SE(@_D{7erNaeo zP;PJ*0nE0`{!nrI>M~~x;`;YBqskzu8nvPbBAUV9) z!39QKJGhUf-oOqzTIVVPq2L6Gz#H^*yz+Z?QPJ=44&V|~lqtLjP-4%+`bS!%|Lo|EiQ#jv|0rcg?CS*8{N;_0z5-RY?V12pA^;}dKWY(N$IE-k zk~vc;N+m1{o#NR@>LuPp8k?jr4(%c%caclL4$_LV3A!q^tJQ2xgiZm0#gz)`3YCHx zFAJIqu^^{-SxA$R|$kB!^1) z5-m7^isNq=BpkjSv>T@ogd4m$w2j#|Eg(=Gjuqq^Vmr6Ht?qvG@l`d4R63O($R~$1 zyas{lV&x&@%2Smy`iU0rr literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/iter_impl.hpp.1C724707D112ABF1.idx b/.cache/clangd/index/iter_impl.hpp.1C724707D112ABF1.idx new file mode 100644 index 0000000000000000000000000000000000000000..478afb3be0f43b13ea767142cee3d99cfe9a6cb8 GIT binary patch literal 13118 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 RTJLUcquO?}(+oC3{C_aK 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 IX6&E;2alG<`v3p{ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/iterator_traits.hpp.043B605EDEF08CD8.idx b/.cache/clangd/index/iterator_traits.hpp.043B605EDEF08CD8.idx new file mode 100644 index 0000000000000000000000000000000000000000..c33ff902af20dac5828d3386888026a68d6f2054 GIT binary patch literal 1678 zcmYL{3rtgI6vuC`K1L^h3`MuHu4L&w;_DH9~R@80BuCjH-=^FQZ&=ey^(Eg~$e z!VJSgG!Z3vnT2W-48wTnUr?Bzz0ANcHS$WD$6}*S++Sxk)|9Gtv9ivYkxLpo&&S4Z z>>q6H3y)SjD*2_mf1%_8G5@6LrE@Art8v|OENk*kS@#C7g#M+z>iM+bD&a%HfiAt; zBikvlx!c{j$|f!_SG>AMcH`h($GoWxzC%GQz8lZ5xyBe4!<4e?x z`1-cP{VnTnYKUzgf4TOAY4EDO82dUdB? z`}Xlar@Y9^tJ3&wuhviRZZLmT?tgVh$N3|MJRTOC2i6_J{EZ|Jk(9Kchx@YftW(BOWQ)yaP_VR z<%`Cm&*Y8DxYp036Br(6rkv`t<@s65Z9NMEqkTz-r}dtD1b^m~YVk9fgGS@xPUYg@ z#t-Md=^9QQc(bX>>;20=3X`L>-pcvOulL7Fl8+9nYwze(T;VH!i)Rx=ctJ$d;@EP> z{L$jvMCNP#N6o6*;;6ADNpsCz)`){z?jX%m78`Um?@m=lx4H)w5hb(T+dJ2cx7gb&17dh#lXxZ_-1$*++A0P%Y7I;ad@EYF?=UT5KZJD-wS}=3O3HoJ^ScW8t zy+kB#$-_u*!dpZO*yAmUn$m;!RV2dNQ1eXPZmW>1a4#!q<)#u(t<=UU-ngK4gYlq4w@fcL6OJi;1JlqxO-e zob4N2r`pkYsNRS0v7rU(w;XqVSAG2ARjS^ER4^3+TEOnDYL(VrlKhH34H`~DNVv3s zed|g{srdVb8LHZplrd!jTEGq%c=pptkAMXd7och>A?48mcC@GF_vZ4)uaS*L^C$dy zw1AD}XMR#3$5*z?An2_g5_pN88k;_Vt)eisQn*R{+c(_M{e%O9O{y@Jhz0;j9V5lO znjb7hVJpna9>Si3IioteYG0g9%EU5vxDcCEh!k$n5&%IbQFK7~fXP9ZzYM#gQA=O3 zuPbZ{ctP0|EWqY$iaq!C8A&3_R>%}S&;;;7*%UjF4cOoWjSJkFP0B6gVwe)pLA4Y& zPz!^gFvSa;1gM}e#R;@*&(j8TuJ_fVxxAgd1L3OzHz=Ee2AaSVg(+B|$?c)Fth2!a zBWfaBCsV?JfDg*1*nt7TMq!E>Xu?STf^p6;IggqMO@stw14SsCLI}b@4+>N0z+i}) xTs0T17rr0{r(p&883h5<;@Pl$3?o)vEmmGRE3c$q&~SUDG2uNE3xdPO{s(}?6uJNa literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/json.hpp.E04643ED2089871F.idx b/.cache/clangd/index/json.hpp.E04643ED2089871F.idx new file mode 100644 index 0000000000000000000000000000000000000000..f84749aaa7e075d1c7d744b4241e5027197bea08 GIT binary patch literal 91492 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/json_custom_base_class.hpp.6B3A4A4E00C191C7.idx b/.cache/clangd/index/json_custom_base_class.hpp.6B3A4A4E00C191C7.idx new file mode 100644 index 0000000000000000000000000000000000000000..4fe268fffbb0f20dbbeab532f529c5db569a1d9d GIT binary patch literal 770 zcmWIYbaVT~#K7R3;#rZKT9U}Zz`!63#Kk2=nX?!f7@U|H7%Ju*4LqH7*FfOwt$4$3 zktmMvB^P=*75lj((TuK9c`*}~04@&s!)U+uM-H}*S8 z@NsJt{81`=Hsgu1!j~tF%x|LO?UIQ`(Gy|Ok=EVD$2+gmoQ&_F4fe_+UhL} zvy?7lz&gzmMg0YTHP)s&3oo?reH5y#b9FXj`d=rRhkyUIKl}9Ny6bksn!mMIW8OUs zHJ*6XPt$a>v+C~^%Cm!d{a-2e-MN3#@t36c8a-R_kp8bKLbDg2+of01UswF^m|fu# zo83!vcwZfh3O%Ww?iBE7gRZhxer4IMYSW}^DO2TEl;3jkYqxCqueZGH%k9+PUDxuj zTTKlMs*yF9x4VBTSUf%?j_I3a)~S_|f&Y5*|Np&}z3=Dg+ojTl*G=mg1Qhi%iYs%I zoPaTvCNk^R-s=8*HUj6X(J*7Z9&?{l+$+Rx3z4pbn|CNBym z7&w`M@eWc@l$ut&9>~0WuRd+JX*CZc5391YvOG**#J}Hyu60~;Kw&ioHEEziFqps? z$I&C|r~nk^W8jm82{+c)e`mFu6b%%XSCcn{83J=96BpQZ&0_k}Pae#4;$c;kP}GDe zg3*jzU>Cv^We3IUUHTON9%!V3tbz(m6+=;KPNE>tUbsN~+O*XnS4yWb6c;5ID}!9b adY#|C^I?X*BNH1711N1n0UM0LzyJV&^Cmz5 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/json_fwd.hpp.343912FD338DE2DF.idx b/.cache/clangd/index/json_fwd.hpp.343912FD338DE2DF.idx new file mode 100644 index 0000000000000000000000000000000000000000..2d8ec3d8ebf220c388237c5ff525882fa8e75d78 GIT binary patch literal 852 zcmWIYbaV4zW?*nm@vO*AElFfyU|9;Z25t0XHssm6Gk#+0 zRxuBqxlt>QoH)Qfr>1kgr{|*wKOCOE_T=w+QKB5Q$fEN6x9Xx@SIZ_iEG{&8By#nN zlUV}K{1uI#v!X9nTn#d3IDV>fuJZ2|%k{#H(+upLz6U?Cy1ByLl+*dzw(Q-LGSyG= zY_bqKy!hcmkFc}ab6*whw(O4if47WhqLi?Wd4%P`d2gp^WVfal-m%~0@ji1>faxAz z7X4dOw%&LbSa`t8e~M>7WZB09LRXe^8S-rCE)+9Ri{@&{dHjS!FY7?yW)a5r3+h`A zmA>`XanLf-z))UK7M^e^ALW4ncQ`}c&^yUZr4Mjblp)hTp3vokc*$xdhEz1!jm zFVDH{>Rx+x*>CH2@3=dwz9bY^<|a7-Lu%_sRn7HnuPwQmc(@r@+}PZNzyt#)0|PMZ z7+F~N?b`KOEOXu=ZYD0E0$Vm)E-(R701RNDf}+&4;$$E*#7{{5#Y7ucCLR_IcMae8 zwP~wEu9QyWVKGoNP>1m%{{0qot>cno-+&W&TJxu_}AgX6_GXB^M=$y8>0K^QjBM%s#k1{r~PxX%C=kP7Y2rm?6QOu6uJ+ z1^R%hH5E1CE`jM{=43HqGZKKA&BJ2LYby@(G!KiLsGB^@8I`6hUpTAlZDZtQF=sOu zf@y&%2HFb>9+)tP-o4d2N@X{Js-4)K;HqnTui2ET^4?+MWKm*Q5{0SeVbSN*7l%3O z?mNktnQuBD1Kq4^sp|w2W++O{Nd)<;xG1?e7{p))5fH$_wz7Yz`i*ZMY^-eT9GuJy YY%m!HP-MXXFt@+}2aLhMz=~i30K;h=i~s-t literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/json_pointer.hpp.FB6E291D7A2902B3.idx b/.cache/clangd/index/json_pointer.hpp.FB6E291D7A2902B3.idx new file mode 100644 index 0000000000000000000000000000000000000000..a527c400b77f8c1152333f3e4a9fd84cf237f7b5 GIT binary patch literal 11734 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/json_ref.hpp.7D03FA6FA42B8F28.idx b/.cache/clangd/index/json_ref.hpp.7D03FA6FA42B8F28.idx new file mode 100644 index 0000000000000000000000000000000000000000..ebf022e1fefa57500e5a7b48f452ceb479a38287 GIT binary patch literal 2082 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 IdTamvKR2eLRsaA1 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/lexer.hpp.CF0733DA6F175E1F.idx b/.cache/clangd/index/lexer.hpp.CF0733DA6F175E1F.idx new file mode 100644 index 0000000000000000000000000000000000000000..e9e5df839134e826611265fa86d79f79f7c445c3 GIT binary patch literal 13706 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 E{~z-RZ2$lO literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/macro_scope.hpp.CD8D41BA56E1C328.idx b/.cache/clangd/index/macro_scope.hpp.CD8D41BA56E1C328.idx new file mode 100644 index 0000000000000000000000000000000000000000..5e543e1b25004e7f8a179c15b2e5c5704bb3fe8e GIT binary patch literal 3096 zcmZ|Rdst2B9tZHf-naCtmYGhuG!>#`m)wRP3b}M4nW8es(TSqO6lqsyV(6sZb%xqH z(S;|W%SdK48YhWChe{WAYK!g?O0F@blJnaSYrlWZdY;;AtlD7jFVsg(BogW2Ur4BAdoO;9sYn!ltR{Jm3th%L^nYEn-u~qMnK}u{QS?CR zT$h^_b6dj~ExWkb&=~UXs8`l~yfIWaeUYie_aCD@#~EYw8FD^=6)be=um6F=HRomA34^FamK4#;P7wTnlJ8-*WpNa3PIphY}Or1cr6hvr>5o9{PTwh&~dX|6g<46@VGHH(f*4j zt$MZOEx#|H5Ki+`h+d>$T%=<~pASV6zpWv&wL~K8*h?3zZm$z@TJ$}E_hiDS<|5J3 z_gh?D46-?dJ_3CV`aSs#62BZJ$O*_9_{&^282QX22-zH;&5aXEIpnV@`@)N;A#@Yy zW(g~sTe+L66V(xV3G^}u*uL!i*%gIK$m94tZjw;ybm*{=-pbKh2%Q8vS;G9fC6%9U z;t`}2q*OJJ#JZ~o%&sJiMQ9|@$P$NYQ`KwjgT^5|C-9tsNphn7nhWPAAaoGuU@$W^ z>wILc_auZz1RgQ)9a79&v&_?&YEiL{ST$IlF3?_JAPk+SNt{L!yDHjQ(t*OUCR4Cl zGv%A6*A%@LR)^zfCioNMngjWP!v0;Tf zw;A*=$u~!6Bhbcx3&}o_p?$>yVVJ-$gSNKASM{>(XCh=#$f6d)nDQ@q{T3iA0R>CE^Ny&Uc*I=G#%Nv(*fZjfrkvj>gx-pr{y^!v=C@vU=r;q%Pbyo zLP(>KMy-TCk~6HFgQu#kMyMoE$u3D_d+{H(Rwf=CPY-iyhdI?6)$N*5Z$CbG113Ij z@PRG&|K5vO)Zz7m5_$;qu+H62>(A?LI`4(hMWBm;(U;y@jlIJg5$+MV$6&mz+p+(I zw0a{n5olsi`rG^pxAbp)5S|fu#=t^6vOp}Guo)qaLLAi>Cb&!gQs~ibC0h`3I6j9P zBfx`n^=6m!mA(ks6tbzc08UHi>MXA*QbIh1c&d6R=387}BH;%75TYqWvqioA-}3Hn z+*kV}q)Oto(9+2tosa29{`>SX-&96C8?ANTHBU6B56KTS|)Z zE0hpLA&Skz>`iUDW5!50!UqB$SSiCt;};(wv-Th~6KG~&Z#ytnJ3dwkGLDyV#zG&P zkGFhidRnT40RjUo@oeDPzBONEMIf|OzMZNPy}uhC{<0t;65%d^yDYIac3sYG&652H zX&j%%O%eKV)8BC-z^^zOp`SoMOK3iE^&jr;i$!Q9(8}O-$+_9G^7J^u(+HgiL!l5J z8AqtT(pn#7Dw0@NpG&l89p&q&xzGns z8>m_Xoh%%eOfdX5$)hP3D+Ka^mcr?(y&jkKpX;8*)8z!pS>b!Ddp&NXw&67aZHubpauoKs4(?Qo4Qr zk&>`tgpUM1va9g7ioa{n*xsuM)dZ?pLVQ|Ny1O*~7D6P2NVe1?Z6v0W;vZ`eUK4oD zN^R4xs=M2nE=Q12kWtkwNEN4eMvYX~BRnSXm?cg`x)#hDZQFp5Kp}xWXBn=VF3~I2 zDj}ESbJ^Q8=hw@rH~pLx2yY3zWu^XiZA+oFyYoK6eFFCxEd8zhM9c=876b(c3eHrx zx;^Q82jz+D+Y$Ct*v}@Yeq~}=Z`E)ILM(w;qFU_I?)xQrP1RipF9^I~eR#}yU?59P z?nW3SFv#GH-;35%_k}$O4+uP9puecx)<1vK8w4q*BW16GNV{n?EaJ&KTw^w4Y*b%7 zJPm>%)j(*R!HD&By?#tr5vXD}ZCtim-DA7zL4-O2b*w)Fv8J@rN<4%xlb@+76ftj` z+YGlEAMtbor<1@gj>Ip}M|q(_BwIqeDgS-ih_E9Psk2=Two4~pKk~3T UE`84^4K;NFqeRLd|DU)21C2!7DF6Tf literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/macro_unscope.hpp.D4E087B7A41F3825.idx b/.cache/clangd/index/macro_unscope.hpp.D4E087B7A41F3825.idx new file mode 100644 index 0000000000000000000000000000000000000000..dcaf6245fad9745be51262f34e8e26d7073ca544 GIT binary patch literal 238 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/main.cpp.B306525CDF572C5F.idx b/.cache/clangd/index/main.cpp.B306525CDF572C5F.idx new file mode 100644 index 0000000000000000000000000000000000000000..005144a9bcf7de334b4d9ac0d8c8a9ae689d48c9 GIT binary patch literal 6832 zcmZ`;30PBC_Rk3qB;*l7-~|XvSY+P>9b`wU;2IHv1uJd{7KO+@wOSQwRaDx+YHgKG za2bRei=)&!l~$&r7Dva8B5FZwD~jSat*vzG|GtbT_xb<6;e(s}-nsYOv)yyfeWXlH zOl(q#L=&^7uFz$dEMi0=kq!APE-7023`C++rXtabniJZ2xi`khZ^UVHBC-n0Q&h(` z-dNw(uzkYiU#_0HRCjRFrQ?5p^7E62{!wbX=j9LG0`1-Y`N1cTht0Q(_c@I?AKv^! z!POw;?x2#%)}{NKE}WHFYn7|desIq+c&6(&K$SA@=3w$)EQeM--N0On|{2$Y)YFd^ywja)rgj>P zPahw9xA4pAq@T?Cek&U_e$?36OJ96?c60x_t;3o3a}NJ%oxe7wzOLi)y?TGE(63tKbZs#)pDEn6J!57a~{PF(%1?q~K<;QbUc1@f8?3S<#bkX&)W_vjR#k4~~8PqP2lzZqMUrBTo8I1-dtg)YK@(G!(*$ZF@i9S_pxFr& zH-UW1qYls?=ywXvo$W}z;F#<*FXtDy)!HxCjKTDGepAI zyC4HuF+{@G&%px3trl7|56Nw4HnAa(mpCnPMnjH^`NpE>?Kf7Ht_eyM}Ho;0DBTQ_BX(*PaEz`8B?z}e<>lj!Z11scsWNq+m zSI45UWJM;IX@`P5zFR7OYw^Fv66@51RXx}uBZk`t(tRLDe5k)-{ou{8FtYv-NDqM= z8C$Q7syx4ILX?>0dSQAmBvF|MzcY$V~z@SM?k`<*kfmaiRpv=5^?Yh7nMPo@|+nuA>>*t-d zyRR*eBg&>IQf!b-e5B-2NV?5rV%&6XdKx}979NXN3JwwJC}>UzM0(5it7`-VNZ`0OQdy+wJP!ToYU}lXx(Fa{3hHPf$|& zEJP<#*PJweu`bCFt=eWt$8E4GnphaBA^M2r;>_YKsNwbSrXF%}(H~PIPueWml1$9g z46ilAL?mDlCEWN5O1Z_F#R}Z02d$opfTh)3@=8f1=CjwRPyv=?J+>NTs5Os+t09Eq z8j#n3g5p|`)C#lYt2vJ4IziqE3N-JWH;Y4*RsrcGiW?!YQOI}?xbFckWbAVP>#gR) zKg=N$OWjMoseBv2eFGTrlq)SN-LIGDG7J|Xi?BvZGMrYS}jZO765Z%09)pV4evv*r%X5B8ayp2ycQ3=o~)ieY+q87h*#~oW*w| z)LBtxQLnh3(}M#tIXt|kXSDC31;q6YKz@}dr)O-A`6G78LIuky8Ko4Nvz#4cC&lK5 zKtL;qD-dLpGLV;nfLaFeWgu8v4)Ss#y&U4o!MGmv zC8p&&IcnNyvuI1Ih8}$M5R9fR=xM%DcV*i$b5g&QON@InoGwCVY$_P8*r(VR^<%ga zuM%U-kpib$IZdvXXT`ErIV^bUQKHipA5!U)0D`PmdLgS>@ha^!*1IN_89pK zDk=h$<(UOUT-{{dOv<(jysIDxaoRttZq7J*rjRJBi_^v9Nn?>$ar31wKde}|nw;ry zS-66(z5uEV;DUPaZC88`Bq09CZlf}OjqMsDS&%%4!(~1>OC+hRd>v8uZI8E&!NYQ! z!DBNR@w^k|d!2`B*ArPnW`rc;>POLQr!OlMZ6Zt;xGr!*5r5$-zOFeovWYNlhH=dh zjVkeYYBMcl;zGZE(+Xw_VY>$ud%zLB^6$x|kGp;xQ%M*%gQ6Mikb}$IlDF$`+56b^n{oMboS$gf0 zQ4I06Oix=S9=qwm11Iu$ydENic!nNk3h_ccWD0Sy9!e>01w|{^A`V?{%@lpOriNIw z3S6sbbGu__ZmrsXRRhtk7ead>5+epzk}C7xYacz84}p0I);Q60@P+TOKYzD}bQ!In zBKqP=9*4I=B;tUI{a^L{e!H0***dVS18a0Q%XNTd2j$3%;?N7uxC6@#fc1dz&M*j; zgLM9G-Nugo(fxX&oZ3$9fDI#lg4l2&#bfu&jg@z951&28`%|eiwh?$wCHnH0RO(Nn zK`ZTJFk%Q({<4ZKeeKPY+K_i)Ip$G?c2*GPv6fw(!#-2$gu;EDM3-Cbq1gJBm<8SW@3j?zftvHB>up;sA_Y5aRA zBZge?Jo+dj9*^sTFl1~td?Womw})5ENj>(-G9D+E%l63@p!|UR5EPo!nI($5S#Mv0;o-|g6&msMJZd_v;UMP{-K+guNB6$LMW<> z`NP!0@SXsJisjTcY9&S-K`ON~MP313!5BC!7ho13F{YaE{>wk@`1dukPY;Cm(BoIR zcgM~AckW&%nJ&;F&;{o+q<*PtK#fO-A@xhuN%MZ;UsH0;o@VzE|7tXvWYm_w#rU41 zPI^%M_qLW5-nYoK5T6i1;tO*L^Txf@vhs*c=I3sa%o$-5;fjx0PHU$XTu#z$(go!= z!zROsVpmE_Pd!~cKteOkF3tG3^1zPbJNajBlgEvqXaqM@X65j~T3gA*9|++z_?(7u z=ndVDW%iNRU49}~3a|(;UKcL@)RBKY?#dlAhKu5&lqev>MRU;t6vM>`P%IZKKyh50 z08QW~7!lV#ag${W>6k(tE(Y2Sy8VNDqt^;we2ajpAN#>7{3yA!Q||7vhBU#9o*p z#3{Y>O$wj6lzp@}jywNAe=t{?gK)32Owww#?bkLpcoYDKLoNN zkW=~)_zZy`#ScLCKuCW8jt^*HGTZ}*dO+pr|6*!a|LFBk$@xtRONyqsK%1bQPEmSn zy5Lrnk(%)a((pD$S{(k(C(U&+W-%TqF)Tj8(0zmh}jW$R^+X|EU5 zx;KI=eEq+b{7vhv9P97GmUso2ES L+>B*LfkgCwnd!Ak~9*vCnE-M+%v_~yv z!#uX9zh5oVY5JZ#A$ig+JBLS#$v%BaS;tF4wuE1tl{ItIDuKSzRh#AQh9+&+d@>2w literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/ordered_map.hpp.0459B1FEA5C8FA57.idx b/.cache/clangd/index/ordered_map.hpp.0459B1FEA5C8FA57.idx new file mode 100644 index 0000000000000000000000000000000000000000..5eb686f8bced5ddbf6aeeeafae541bc199784cc8 GIT binary patch literal 6956 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 aqND#>s4JOIZ4e4sEVg$LN$e;)tNZ`raWXal literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/parser.hpp.917EE895F45C94B2.idx b/.cache/clangd/index/parser.hpp.917EE895F45C94B2.idx new file mode 100644 index 0000000000000000000000000000000000000000..5b04383dbf71c9900805a8823e3d93959ea7d778 GIT binary patch literal 7988 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 Mzm24O$&yI^2cySHP5=M^ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/position_t.hpp.89E0F348D620259C.idx b/.cache/clangd/index/position_t.hpp.89E0F348D620259C.idx new file mode 100644 index 0000000000000000000000000000000000000000..afc6917cef2eccd52ab31d20c06534715d762c31 GIT binary patch literal 758 zcmWIYbaQ*h#K7R3;#rZKT9U}Zz`!63#Kk2=nZJNEA5gAh&e6b)e$IwGXO^cV9%br$ zn#-!<#%8BbB)ng3!i|H4|K^8#X?nczkX!TlXN}eF8G-HrheRHQsBR13p8UIUwnW(W zXVaD*2yfYOiCa!GwEhObOwQz3r|8ncr-zG1Nx z?!`Tw{Wo&8Do;OYUpUMD@}4#GUtB+L{z-b{Z-x^lM>&csbCc!*L%^8#pX1UQ3yk@g z7&#bNBm^YX!2|;bP!0&bX&*~`8l@V|$HWGdmJ*PX0uwOlmg`LnnbR~E^D!|2rNsoq z6u<;bdhYEg(d&K7S4l8&0;Og7WW~S)OnQ|!7>fiaGw zN7PXPD9p#eCkqpXd6kh1>_wREFfRgyLH>gYyX|Rxm-8lVJ~I!C7^fIN%%?mo5}XqJ zFr#=_q&TJcVJ5)TFmZuH0cH{pi#)%)Jj~57nvn?{7BEFH8t4j8Ks1Z#OFwxq(+L;? mIf)<-6c;5ID}xv;?;hff*zM0jw|v0|Nk4#Pe4G literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/primitive_iterator.hpp.78C60DACBF4B20D3.idx b/.cache/clangd/index/primitive_iterator.hpp.78C60DACBF4B20D3.idx new file mode 100644 index 0000000000000000000000000000000000000000..105980edd4ad82515f65fe1d504a2a48a593266b GIT binary patch literal 2454 zcmYjR2~bm46#e-|O`eY=5CchA6ZmW@fr?0Ism>*0#4W!rb<&W#PV<(<=?6;E#bKF+_pVlY{LphvP# zU%$RX5slaKnoxGw3);_5I z)2IAk5VkibTix)P_iaN|XR`LhNr$s1s)W4%Q=~%?8(6;#IZe2uH%dqFOgn^3TuNK95 zofr4N@M-wVU3=lUYep1v;`p|OUN1WyH&l0I-tO`|XLWquy^G2O#U!!yoDoIl)lcu1 zPw(Hlai5!G@XFr$`oQ7-CG($MbFDq`jeA38*2wIp2$PL{@4^z_*p0XC!)|R{{&>yRz?d6tzuL@902{{Yxk~c9oNz%w1Utj$`UmPKxZvZJeay$ zpCO?|g!Xju^xy#K<^LQ4o8CJj??0JJ=A`=gP-vBeW;0im6dvw{PlJvIgD z|8D$ZwS;yew7<|_!U528TOunPP6t;>Xc?gsm5FK&fPS?5pLJslztu@-M?(7ueQY=Y zdPCI@jz3OWdwg_viXugYSOEHnIrY|&p*JTbw3zG;mIm8%0Q4L~@0kTt|7()bd_uc0 zF1{Q9y}qgF$fd!RmqtsPu1r@W7Jz;cU6*uI=y(NFN>WmT(xB$RQqrEX?60fp2Jerj z9f*U&I0q#M6d5RFc95D^CoP%YIeE(~OxY0!6Jwgf0T)3qjyU9{eUg8f%oylB8^rY- z1jfi)>@9`rVdN|D#gH(J0t5jVl8;e{I7ABRz$jcCE`_pUq?79G-Zm)GIqO_4E2GqC z_x7g9=wwt|R`Jq!ySH~h@lNq-%PI*aiJ-O^rJ__3)C!}eXsHO2i%~Ah6@hv%DiRc7 zXm*TB1*I687kqd$rz}W9{K#wT$TH-_!^q5|%sl&1JyO(W-p7IsvRN*K5L04DFvHbI z7*>X6TaA71gB{_ZKVoLZ2hrguG#|x?W30i8=F|sHpuRDPQyrK|3B&<%O9{g5!d)Qg za4GUTR*ta6YoxOE6w{tg&djJ74b&Y<%tM?o!CO-1F?im!GndB5S>@~vLL_^qF`=** z{z&$+(uKX?EJU1I!HkiM%*73afssn4a)axUxO_$maWV1~c{;+$Fp74Keh<=vkx6E9 zvou2?Q|J$w#HfTR@rV0EcF5`2(E!JQ&LQbxM*^6~o~v{)^0KQ)dR%E&2Pi4@JPE>1 z2=K0c`152%W9I=jnX?!z931+P#Aas&c!M}d5Oz?28B)PV+-v|d$&8;W#F80bv9A)2 zLBwVkqK0_T=;U|o^nd`MB4TDo2ecv3BE-!KFk=+SL^Zma>@irXSt)Gk^79twYuFEDT^8H7$z8T{47Qp;Vb(PISiuKHO|X3a E4<7768~^|S literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/serializer.hpp.34499B757C5C4B4C.idx b/.cache/clangd/index/serializer.hpp.34499B757C5C4B4C.idx new file mode 100644 index 0000000000000000000000000000000000000000..9a990ee295eebda6f590395e902f5f8eaf227eff GIT binary patch literal 12906 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 X9^1olG@ABPKaIwnDYQq2YBc`~553t? literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/std_fs.hpp.BC781634FF7DA14A.idx b/.cache/clangd/index/std_fs.hpp.BC781634FF7DA14A.idx new file mode 100644 index 0000000000000000000000000000000000000000..af827ef7f7a8a9830e7c18ca71c44a7b6c803ccb GIT binary patch literal 426 zcmWIYbaPw8$iU#7;#rZKT9U}Zz`!63#Kk2=nHzz0Dp0Os&e1-{E+<0)mtx87VqAHf zibc|1Ch>hZdH#LAlBZQ!xmfYMTvYO&>~< zCTd=sux8r(<`1a{=UL8cZne~?4N~SjR-_X?EoY^c*StaQ2>Z3A4C* zK}u}X1n#VkLzCU!ZSmc^d;9-Ni7V4Guh!SMow~1<_f4KZvHZa1Yx$cTtx3D;U~G89+lCdmU`zV2VW&$beaJDZ%^)oem1UT~7{}2g>Zkw|7Gn^Tg$eJHl@99fe_ zq*+W~`pJWtP7TiL%%yeDzXDZ@u!%^*R0HkKNd$3GjtG!%}N@c1jPFHBG#Y9JCRZQ=*f1yk_5P+qAaV+Ev5L z4wmMAd2aiFtr5T98~I|{gSQ6P?x-Bl@Y$>(D>UvolLIPKI_9C79fyY1H(t)Wf4E}j z(JPCeFTQIWIi_H=YJ#;&eWocd%_7S$Ip$Tmv^h^+d~9f+R@bIct?IbuRrNb{dptWX zOD~2h21Z9j_C5RF`g+AKbN-{t^NxF-c)88%@rxu&L-pX}%(@Re1z*VuY8QH@viCcS zybEfcZa8x5L){CN3yS^j&W?gJofF*e_wt(&dumk6_a*U>?niD-Sfg?XIC>#v>o#^z zlGlx%?fW;ZY>$w6?wuR#7z2V9xei;r@J`*t+>y=C$M(;iozdv4jSTvAP@J}I>}H3n zaS76^L(XSyiMcp&#)R!Yr_?DmyN8F~G|pb9+jnr!uuB(rZz_HIsO5IeEWx-+=kTJE z{On`_0B$WW>Qx=1BoMgu1!x=`r{n_=O9Y_5D}x+cp0;-UC{;lS6d168Q7mB8uYQ17 z%m5j{pz|(HtBrk*_p)aRfgwu71t4aH_AHhM<=dT4_fCdDiL)r=3LPJSxMxq`A;%dq zJ^gQG_&&>$2)r>MTokV20}#77V`X80t#<7vK7tEYiNGBL;zjWue4v2U4g0JWE7%f= zpdSVpLmk4@eK$s{D@qq#+S2WKL z%b&Z&-i5#1Ux$z!>3~@3Xz$`?#>^)1hV@_Ad6>(ry#=Hxa9|X25-5y4yom8 zoS~QKRTX!36z@Aw-D%G-4Ng;{WSHEohUNP$^M2V_+bI#KaHG+pXb(QnMmyZus;HRM z+Y*5n2AD)94Ie0An$Xf#J$^n0cw&HAWY+M30;XDXistm7`Vz6cu0C=LP+#k;j({jf znB&wXK2#_ybn0pxl?Y3mZjvTYIU_7*oVut*Hb!V;oQN*TFT=i4C3ywWBz`leMRNJS zdvo&3XD*RtEMg#9#(-sv8Vi;GEM+o#+7w0|zTpB~wB)kyk=$>mxZ4H`Axe-WxY2f# zBuQ?x-84y>8*MgQob5_zYPn%s6fnOk5hn=KhYcihg~-^?7(mnwQM6Zd5ZPgf;=SU7 z$k`#M(2?a&AEm^@$wSj6Oyr~S8PFv%6xch^vrG7B5#zjw(Gt?hsm0`TN0uZ!7S;C6 z=}QUOJs`5WTGga}OuZ^cPge!b1xm_7p{h_%S0${gFQI#`#%8HFq*%&>kg0v@K zc}pNwK$NM;3?&Z{d%&e~-atTvHX+NK0l5s(XwB#$w45>8F$P*rx;EWF^1dsMY|OVh zFUFf)$#_>Xex$0XLlr;g-OH&HL8O2R8Q~rxHB`$ey$B*1rB@I2GP)7o(7PMbANqG8 z$=>6gbcok@L+N>AqqE#kESb= zpDBd6J4B`glcn3L*i=eaWG%K%{!H}fd+pNtb?oDM8M5@`~P#u7?ufha?pF_fs9P==j_o0Q}c z!VkX8%|~*1rqW?nwZqFN|C2XPwdQ4U1E^@~xT0w8kA@5O4_bbC*LH2=*29i{bb5^z S^dUC@(9yqo`nPM80q`eOKOE-( literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/string_escape.hpp.429D33996FBBADFB.idx b/.cache/clangd/index/string_escape.hpp.429D33996FBBADFB.idx new file mode 100644 index 0000000000000000000000000000000000000000..466cfa3abeaf8938c82374509b5e851974703f2d GIT binary patch literal 934 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 IX-@zAAGwQ9j{pDw literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/to_json.hpp.29AC21C047FF28B3.idx b/.cache/clangd/index/to_json.hpp.29AC21C047FF28B3.idx new file mode 100644 index 0000000000000000000000000000000000000000..e1f1588e700daff9de1da0fdc0b4d05e30a775a3 GIT binary patch literal 11478 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

-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 D{B2e9 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/value_t.hpp.05988CCF4C034D74.idx b/.cache/clangd/index/value_t.hpp.05988CCF4C034D74.idx new file mode 100644 index 0000000000000000000000000000000000000000..20a17a7596ad1f6e5d66e8bdf75ea5c58a5e18df GIT binary patch literal 1910 zcmYk73p7-D9LN8-%)>C(UiR)b$)h0 z%Z?V=n6%{qyQ8$dO`GPKq;CF%!(4KHXpN!AKAHNhODV~*q?8`*i&Fu*LxmQno4o~n zol3dPh=P7MfoGQmP33F&O#5I7!ICcAu>R75Y(lyM?_pKJ++UH2W9P$X>h$=1C?-~-xohjyb zACwEZm(F)oDunX|~}oaS?tRcW9&Swnf$I zRR1e3^ObH#ob^1P44$fbaaDJ#9Zy^*>xUTMS45{OlkEDS)w=WkA{}RoVe?ns&rQRo zWMg6*&J>@x|9Ob-c#S)*RevPDvW#uutNoZZo-=8Cvw>lJZ^D;&FQOpw;?2i`<9llC z%s-tbwDQmPXYvkRXK`n%Sc1mcQqYo|$R8MSDD-l1GOguV_a>1lE44^2Mmjf-$)&+0 zI8LIwqDSEUhxcQ?phVfxb(gzNA6G`q;N7je`w!>OkEWD;Xc1+v+)B+~nd`Otd&SJ7 z-0;R=alhFqk!FhaZLf^#I3Yu^BD(0LNv)SBTRCh*Z1ed7J53Xwjqb?FbL~%pbmsD( zjS0hF*ETBGpS-MC;n)1$ttMDW>5JbbCC|h4k;1IrDld(U72ZfxO--3rI+V97!f^C? zdTg=ClXZdZ&kAU(s4UfSqeRsDV0d3EO)VvzF!}aR8*d(WFPY-Q-8L* zgYf9~)BMOFVO^_Zcv)K8JLb_KVRUD5TCX3|(l7V6bDl|QZPxY6?^Y8XSx$@GDRqa* zR;vlk&zl1pTBVZeDs;L3 zQ$;f$3dg)2G~5~Q_{=OFZ4%%9Nh!qab@iXK-WoZBk;8c|n%hDl0V_j9a%(dX`lv0h zgigPV%8K=Vv?M*KuV)k;&k4yA1E6rSr;)dC7oq}9B>>w)_UkYKBmmSDrNv;$SoavU zm&RrUD%gMkHjoV&6BN+JfSu;m2GurWG%8R>00+nc#smdaFyO!dcXzygsxcL4Ab=fY zN5cdKR58FoWiHvLMBju8WDvj!a+1LW1!OUxLGp6vL(sE_3X~DR60#&>f&%L?AcUdb zl-`^iKm}3=;0QUAF+l+W1}Mfns4U89IZFXL3IL|VbY)BcNkSYDDadPf<}N~X*|ZB( zKtg7)g>0oUL1!RiGjzD<7dBn3uAl-40jwcw5+*1hi2*XcgrIQBs~1$Dg#cEN6&Vv0 z(8hpvi43pS%np$x&_njHMS2Sj6BIy#K=#08hehj&uVo@e#o*(Yq?^<#4LraT8J$V(HpUvu%BYY+v7Ay^wfCJO8W`FvLeL&4uw9EkI+;x!G8CO|KrA?M6cVSIZZ z{E{Hcp*I9y4u49Ju`7YU7zL(l(GAu%PB*99;uYYsBln^EisrJSe?~j-M4VAyNhNeo dQjWGxo(gEF`CpUAI{?V7b*XDz^l$b5_AlVyx32&I literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/void_t.hpp.43EA37E1B3A26608.idx b/.cache/clangd/index/void_t.hpp.43EA37E1B3A26608.idx new file mode 100644 index 0000000000000000000000000000000000000000..0e79dceb7f33b702547fcfa0d6ca45eae6ffd5df GIT binary patch literal 600 zcmWIYbaM+}VqkDi@vO*AElFfyU|rq6OLJx zT8B>6(lRufV*BZ7Oj5_=2|u(HkJK-J$nxsIxhLoQ-z(nC&9`s6c#k_(WLIU@eCzFd zv&!?-oc-P%>2zc0&|+D}#Ln9tu#K(1G^~F8)?XgpPt*Qv6OiFu`?$d2FsHO_z_PAo zrSs=)-Q=1%p`xkQ>%%3J`6^SG<~T>CHO(>Mdd9Qb{=tzrgOJ?vjZ^CTm8UbMKfQUo zeBQYawvQ_xw;#-(^FaG&-GjOnk1JTiXWF~(KXZCp{h_sH@3;ea=l&_K%uSjP^jEW( zzVwp^Go6^2m^px4AYkR?;uT=vgm4&Y?{2;!y1R;-iJOaoRftQ74@@vX)t3L-yjFqb z&@474c1{LX0R;g~Fu}md1Pm?)MpjnyN6Lv+*^@RiF|omn=V9QHW#EMv&lo$Aapkpp zAGw)$fciz`MO48ALO(-MYFcqWP;tb+--51nTyl&&tl|vf(ookiOkj-T=n-{P01AW6 zg^5F*&BO(EF3g!ctRl`L?l4PXqCiC;m%~B=sK`*n3Z@87bAeq3Qv`HZP9n&%;-chY YaS#KPV4#3i==t%~so$RqFtRWJ0FA`CF8}}l literal 0 HcmV?d00001 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7db6c4b --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build +Data \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..12b84df --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,55 @@ +cmake_minimum_required(VERSION 3.20) +project(StatisticCalculatorTools) + +set(DBH DatabaseHandler) +set(TRADE TradeOffComparator) +set(CSV CSVToLatex) + +find_package(SQLite3 REQUIRED) + +file(GLOB_RECURSE + SRCS_DBH + DatabaseGenerator/src/* +) + +file(GLOB_RECURSE + SRCS_TRADE + TradeOffsComparator/src/* +) + +file(GLOB_RECURSE + SRCS_CSV + CSVToLatex/src/* +) + +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "bin/${CMAKE_BUILD_TYPE}") + +add_executable(${DBH} ${SRCS_DBH}) +add_executable(${TRADE} ${SRCS_TRADE}) +add_executable(${CSV} ${SRCS_CSV}) + +set_property(TARGET ${DBH} PROPERTY CXX_STANDARD 17) +set_property(TARGET ${TRADE} PROPERTY CXX_STANDARD 17) +set_property(TARGET ${CSV} PROPERTY CXX_STANDARD 17) + +# ------- Inclusion de JSONfMC++ -------- +# JSONfMC++ Lib pour gestion fichier JSON, en mode header only. + +set(JSONlib_DIR ./lib/CMake/Linux) + +find_package(JSONlib REQUIRED) + +if(JSONlib_FOUND) + message("lib JSONFMC++ Trouvé") +else() + message("lib JSONFMC++ Introuvable") +endif() +# --------------------------------------- + + +include_directories(${JSONFMCPP_INCLUDE_DIRS}) + +target_link_libraries(${DBH} PRIVATE SQLite::SQLite3) + + + diff --git a/CSVToLatex/src/main.cpp b/CSVToLatex/src/main.cpp new file mode 100644 index 0000000..4a680aa --- /dev/null +++ b/CSVToLatex/src/main.cpp @@ -0,0 +1,6 @@ +#include + +int main(int argc, char** argv) +{ + return 0; +} \ No newline at end of file diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/adl_serializer.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/adl_serializer.hpp new file mode 100644 index 0000000..56a606c --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/adl_serializer.hpp @@ -0,0 +1,55 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include + +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN + +/// @sa https://json.nlohmann.me/api/adl_serializer/ +template +struct adl_serializer +{ + /// @brief convert a JSON value to any value type + /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/ + template + static auto from_json(BasicJsonType && j, TargetType& val) noexcept( + noexcept(::nlohmann::from_json(std::forward(j), val))) + -> decltype(::nlohmann::from_json(std::forward(j), val), void()) + { + ::nlohmann::from_json(std::forward(j), val); + } + + /// @brief convert a JSON value to any value type + /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/ + template + static auto from_json(BasicJsonType && j) noexcept( + noexcept(::nlohmann::from_json(std::forward(j), detail::identity_tag {}))) + -> decltype(::nlohmann::from_json(std::forward(j), detail::identity_tag {})) + { + return ::nlohmann::from_json(std::forward(j), detail::identity_tag {}); + } + + /// @brief convert any value type to a JSON value + /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/ + template + static auto to_json(BasicJsonType& j, TargetType && val) noexcept( + noexcept(::nlohmann::to_json(j, std::forward(val)))) + -> decltype(::nlohmann::to_json(j, std::forward(val)), void()) + { + ::nlohmann::to_json(j, std::forward(val)); + } +}; + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/byte_container_with_subtype.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/byte_container_with_subtype.hpp new file mode 100644 index 0000000..91382cd --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/byte_container_with_subtype.hpp @@ -0,0 +1,103 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // uint8_t, uint64_t +#include // tie +#include // move + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN + +/// @brief an internal type for a backed binary type +/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/ +template +class byte_container_with_subtype : public BinaryType +{ + public: + using container_type = BinaryType; + using subtype_type = std::uint64_t; + + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ + byte_container_with_subtype() noexcept(noexcept(container_type())) + : container_type() + {} + + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ + byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b))) + : container_type(b) + {} + + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ + byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b)))) + : container_type(std::move(b)) + {} + + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ + byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b))) + : container_type(b) + , m_subtype(subtype_) + , m_has_subtype(true) + {} + + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ + byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b)))) + : container_type(std::move(b)) + , m_subtype(subtype_) + , m_has_subtype(true) + {} + + bool operator==(const byte_container_with_subtype& rhs) const + { + return std::tie(static_cast(*this), m_subtype, m_has_subtype) == + std::tie(static_cast(rhs), rhs.m_subtype, rhs.m_has_subtype); + } + + bool operator!=(const byte_container_with_subtype& rhs) const + { + return !(rhs == *this); + } + + /// @brief sets the binary subtype + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/ + void set_subtype(subtype_type subtype_) noexcept + { + m_subtype = subtype_; + m_has_subtype = true; + } + + /// @brief return the binary subtype + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/ + constexpr subtype_type subtype() const noexcept + { + return m_has_subtype ? m_subtype : static_cast(-1); + } + + /// @brief return whether the value has a subtype + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/ + constexpr bool has_subtype() const noexcept + { + return m_has_subtype; + } + + /// @brief clears the binary subtype + /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/ + void clear_subtype() noexcept + { + m_subtype = 0; + m_has_subtype = false; + } + + private: + subtype_type m_subtype = 0; + bool m_has_subtype = false; +}; + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/abi_macros.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/abi_macros.hpp new file mode 100644 index 0000000..f48b9eb --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/abi_macros.hpp @@ -0,0 +1,100 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/from_json.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/from_json.hpp new file mode 100644 index 0000000..aa2f0cb --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/from_json.hpp @@ -0,0 +1,497 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +#include +#include +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_null())) + { + JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j)); + } + n = nullptr; +} + +// overloads for basic_json template parameters +template < typename BasicJsonType, typename ArithmeticType, + enable_if_t < std::is_arithmetic::value&& + !std::is_same::value, + int > = 0 > +void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val) +{ + switch (static_cast(j)) + { + case value_t::number_unsigned: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_integer: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_float: + { + val = static_cast(*j.template get_ptr()); + break; + } + + case value_t::null: + case value_t::object: + case value_t::array: + case value_t::string: + case value_t::boolean: + case value_t::binary: + case value_t::discarded: + default: + JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); + } +} + +template +inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_boolean())) + { + JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j)); + } + b = *j.template get_ptr(); +} + +template +inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_string())) + { + JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); + } + s = *j.template get_ptr(); +} + +template < + typename BasicJsonType, typename StringType, + enable_if_t < + std::is_assignable::value + && is_detected_exact::value + && !std::is_same::value + && !is_json_ref::value, int > = 0 > +inline void from_json(const BasicJsonType& j, StringType& s) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_string())) + { + JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); + } + + s = *j.template get_ptr(); +} + +template +inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val) +{ + get_arithmetic_value(j, val); +} + +template +inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val) +{ + get_arithmetic_value(j, val); +} + +template +inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val) +{ + get_arithmetic_value(j, val); +} + +#if !JSON_DISABLE_ENUM_SERIALIZATION +template::value, int> = 0> +inline void from_json(const BasicJsonType& j, EnumType& e) +{ + typename std::underlying_type::type val; + get_arithmetic_value(j, val); + e = static_cast(val); +} +#endif // JSON_DISABLE_ENUM_SERIALIZATION + +// forward_list doesn't have an insert method +template::value, int> = 0> +inline void from_json(const BasicJsonType& j, std::forward_list& l) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + l.clear(); + std::transform(j.rbegin(), j.rend(), + std::front_inserter(l), [](const BasicJsonType & i) + { + return i.template get(); + }); +} + +// valarray doesn't have an insert method +template::value, int> = 0> +inline void from_json(const BasicJsonType& j, std::valarray& l) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + l.resize(j.size()); + std::transform(j.begin(), j.end(), std::begin(l), + [](const BasicJsonType & elem) + { + return elem.template get(); + }); +} + +template +auto from_json(const BasicJsonType& j, T (&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) +-> decltype(j.template get(), void()) +{ + for (std::size_t i = 0; i < N; ++i) + { + arr[i] = j.at(i).template get(); + } +} + +template +inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/) +{ + arr = *j.template get_ptr(); +} + +template +auto from_json_array_impl(const BasicJsonType& j, std::array& arr, + priority_tag<2> /*unused*/) +-> decltype(j.template get(), void()) +{ + for (std::size_t i = 0; i < N; ++i) + { + arr[i] = j.at(i).template get(); + } +} + +template::value, + int> = 0> +auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/) +-> decltype( + arr.reserve(std::declval()), + j.template get(), + void()) +{ + using std::end; + + ConstructibleArrayType ret; + ret.reserve(j.size()); + std::transform(j.begin(), j.end(), + std::inserter(ret, end(ret)), [](const BasicJsonType & i) + { + // get() returns *this, this won't call a from_json + // method when value_type is BasicJsonType + return i.template get(); + }); + arr = std::move(ret); +} + +template::value, + int> = 0> +inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, + priority_tag<0> /*unused*/) +{ + using std::end; + + ConstructibleArrayType ret; + std::transform( + j.begin(), j.end(), std::inserter(ret, end(ret)), + [](const BasicJsonType & i) + { + // get() returns *this, this won't call a from_json + // method when value_type is BasicJsonType + return i.template get(); + }); + arr = std::move(ret); +} + +template < typename BasicJsonType, typename ConstructibleArrayType, + enable_if_t < + is_constructible_array_type::value&& + !is_constructible_object_type::value&& + !is_constructible_string_type::value&& + !std::is_same::value&& + !is_basic_json::value, + int > = 0 > +auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr) +-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}), +j.template get(), +void()) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + + from_json_array_impl(j, arr, priority_tag<3> {}); +} + +template < typename BasicJsonType, typename T, std::size_t... Idx > +std::array from_json_inplace_array_impl(BasicJsonType&& j, + identity_tag> /*unused*/, index_sequence /*unused*/) +{ + return { { std::forward(j).at(Idx).template get()... } }; +} + +template < typename BasicJsonType, typename T, std::size_t N > +auto from_json(BasicJsonType&& j, identity_tag> tag) +-> decltype(from_json_inplace_array_impl(std::forward(j), tag, make_index_sequence {})) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + + return from_json_inplace_array_impl(std::forward(j), tag, make_index_sequence {}); +} + +template +inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_binary())) + { + JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j)); + } + + bin = *j.template get_ptr(); +} + +template::value, int> = 0> +inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_object())) + { + JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j)); + } + + ConstructibleObjectType ret; + const auto* inner_object = j.template get_ptr(); + using value_type = typename ConstructibleObjectType::value_type; + std::transform( + inner_object->begin(), inner_object->end(), + std::inserter(ret, ret.begin()), + [](typename BasicJsonType::object_t::value_type const & p) + { + return value_type(p.first, p.second.template get()); + }); + obj = std::move(ret); +} + +// overload for arithmetic types, not chosen for basic_json template arguments +// (BooleanType, etc..); note: Is it really necessary to provide explicit +// overloads for boolean_t etc. in case of a custom BooleanType which is not +// an arithmetic type? +template < typename BasicJsonType, typename ArithmeticType, + enable_if_t < + std::is_arithmetic::value&& + !std::is_same::value&& + !std::is_same::value&& + !std::is_same::value&& + !std::is_same::value, + int > = 0 > +inline void from_json(const BasicJsonType& j, ArithmeticType& val) +{ + switch (static_cast(j)) + { + case value_t::number_unsigned: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_integer: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_float: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::boolean: + { + val = static_cast(*j.template get_ptr()); + break; + } + + case value_t::null: + case value_t::object: + case value_t::array: + case value_t::string: + case value_t::binary: + case value_t::discarded: + default: + JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); + } +} + +template +std::tuple from_json_tuple_impl_base(BasicJsonType&& j, index_sequence /*unused*/) +{ + return std::make_tuple(std::forward(j).at(Idx).template get()...); +} + +template < typename BasicJsonType, class A1, class A2 > +std::pair from_json_tuple_impl(BasicJsonType&& j, identity_tag> /*unused*/, priority_tag<0> /*unused*/) +{ + return {std::forward(j).at(0).template get(), + std::forward(j).at(1).template get()}; +} + +template +inline void from_json_tuple_impl(BasicJsonType&& j, std::pair& p, priority_tag<1> /*unused*/) +{ + p = from_json_tuple_impl(std::forward(j), identity_tag> {}, priority_tag<0> {}); +} + +template +std::tuple from_json_tuple_impl(BasicJsonType&& j, identity_tag> /*unused*/, priority_tag<2> /*unused*/) +{ + return from_json_tuple_impl_base(std::forward(j), index_sequence_for {}); +} + +template +inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple& t, priority_tag<3> /*unused*/) +{ + t = from_json_tuple_impl_base(std::forward(j), index_sequence_for {}); +} + +template +auto from_json(BasicJsonType&& j, TupleRelated&& t) +-> decltype(from_json_tuple_impl(std::forward(j), std::forward(t), priority_tag<3> {})) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + + return from_json_tuple_impl(std::forward(j), std::forward(t), priority_tag<3> {}); +} + +template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator, + typename = enable_if_t < !std::is_constructible < + typename BasicJsonType::string_t, Key >::value >> +inline void from_json(const BasicJsonType& j, std::map& m) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + m.clear(); + for (const auto& p : j) + { + if (JSON_HEDLEY_UNLIKELY(!p.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j)); + } + m.emplace(p.at(0).template get(), p.at(1).template get()); + } +} + +template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator, + typename = enable_if_t < !std::is_constructible < + typename BasicJsonType::string_t, Key >::value >> +inline void from_json(const BasicJsonType& j, std::unordered_map& m) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); + } + m.clear(); + for (const auto& p : j) + { + if (JSON_HEDLEY_UNLIKELY(!p.is_array())) + { + JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j)); + } + m.emplace(p.at(0).template get(), p.at(1).template get()); + } +} + +#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM +template +inline void from_json(const BasicJsonType& j, std_fs::path& p) +{ + if (JSON_HEDLEY_UNLIKELY(!j.is_string())) + { + JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); + } + p = *j.template get_ptr(); +} +#endif + +struct from_json_fn +{ + template + auto operator()(const BasicJsonType& j, T&& val) const + noexcept(noexcept(from_json(j, std::forward(val)))) + -> decltype(from_json(j, std::forward(val))) + { + return from_json(j, std::forward(val)); + } +}; + +} // namespace detail + +#ifndef JSON_HAS_CPP_17 +/// namespace to hold default `from_json` function +/// to see why this is required: +/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html +namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces) +{ +#endif +JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers) + detail::static_const::value; +#ifndef JSON_HAS_CPP_17 +} // namespace +#endif + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_chars.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_chars.hpp new file mode 100644 index 0000000..e10741c --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_chars.hpp @@ -0,0 +1,1118 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2009 Florian Loitsch +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // array +#include // signbit, isfinite +#include // intN_t, uintN_t +#include // memcpy, memmove +#include // numeric_limits +#include // conditional + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief implements the Grisu2 algorithm for binary to decimal floating-point +conversion. + +This implementation is a slightly modified version of the reference +implementation which may be obtained from +http://florian.loitsch.com/publications (bench.tar.gz). + +The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch. + +For a detailed description of the algorithm see: + +[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with + Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming + Language Design and Implementation, PLDI 2010 +[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately", + Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language + Design and Implementation, PLDI 1996 +*/ +namespace dtoa_impl +{ + +template +Target reinterpret_bits(const Source source) +{ + static_assert(sizeof(Target) == sizeof(Source), "size mismatch"); + + Target target; + std::memcpy(&target, &source, sizeof(Source)); + return target; +} + +struct diyfp // f * 2^e +{ + static constexpr int kPrecision = 64; // = q + + std::uint64_t f = 0; + int e = 0; + + constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {} + + /*! + @brief returns x - y + @pre x.e == y.e and x.f >= y.f + */ + static diyfp sub(const diyfp& x, const diyfp& y) noexcept + { + JSON_ASSERT(x.e == y.e); + JSON_ASSERT(x.f >= y.f); + + return {x.f - y.f, x.e}; + } + + /*! + @brief returns x * y + @note The result is rounded. (Only the upper q bits are returned.) + */ + static diyfp mul(const diyfp& x, const diyfp& y) noexcept + { + static_assert(kPrecision == 64, "internal error"); + + // Computes: + // f = round((x.f * y.f) / 2^q) + // e = x.e + y.e + q + + // Emulate the 64-bit * 64-bit multiplication: + // + // p = u * v + // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi) + // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi ) + // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 ) + // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 ) + // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3) + // = (p0_lo ) + 2^32 (Q ) + 2^64 (H ) + // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H ) + // + // (Since Q might be larger than 2^32 - 1) + // + // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H) + // + // (Q_hi + H does not overflow a 64-bit int) + // + // = p_lo + 2^64 p_hi + + const std::uint64_t u_lo = x.f & 0xFFFFFFFFu; + const std::uint64_t u_hi = x.f >> 32u; + const std::uint64_t v_lo = y.f & 0xFFFFFFFFu; + const std::uint64_t v_hi = y.f >> 32u; + + const std::uint64_t p0 = u_lo * v_lo; + const std::uint64_t p1 = u_lo * v_hi; + const std::uint64_t p2 = u_hi * v_lo; + const std::uint64_t p3 = u_hi * v_hi; + + const std::uint64_t p0_hi = p0 >> 32u; + const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu; + const std::uint64_t p1_hi = p1 >> 32u; + const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu; + const std::uint64_t p2_hi = p2 >> 32u; + + std::uint64_t Q = p0_hi + p1_lo + p2_lo; + + // The full product might now be computed as + // + // p_hi = p3 + p2_hi + p1_hi + (Q >> 32) + // p_lo = p0_lo + (Q << 32) + // + // But in this particular case here, the full p_lo is not required. + // Effectively we only need to add the highest bit in p_lo to p_hi (and + // Q_hi + 1 does not overflow). + + Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up + + const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u); + + return {h, x.e + y.e + 64}; + } + + /*! + @brief normalize x such that the significand is >= 2^(q-1) + @pre x.f != 0 + */ + static diyfp normalize(diyfp x) noexcept + { + JSON_ASSERT(x.f != 0); + + while ((x.f >> 63u) == 0) + { + x.f <<= 1u; + x.e--; + } + + return x; + } + + /*! + @brief normalize x such that the result has the exponent E + @pre e >= x.e and the upper e - x.e bits of x.f must be zero. + */ + static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept + { + const int delta = x.e - target_exponent; + + JSON_ASSERT(delta >= 0); + JSON_ASSERT(((x.f << delta) >> delta) == x.f); + + return {x.f << delta, target_exponent}; + } +}; + +struct boundaries +{ + diyfp w; + diyfp minus; + diyfp plus; +}; + +/*! +Compute the (normalized) diyfp representing the input number 'value' and its +boundaries. + +@pre value must be finite and positive +*/ +template +boundaries compute_boundaries(FloatType value) +{ + JSON_ASSERT(std::isfinite(value)); + JSON_ASSERT(value > 0); + + // Convert the IEEE representation into a diyfp. + // + // If v is denormal: + // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1)) + // If v is normalized: + // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1)) + + static_assert(std::numeric_limits::is_iec559, + "internal error: dtoa_short requires an IEEE-754 floating-point implementation"); + + constexpr int kPrecision = std::numeric_limits::digits; // = p (includes the hidden bit) + constexpr int kBias = std::numeric_limits::max_exponent - 1 + (kPrecision - 1); + constexpr int kMinExp = 1 - kBias; + constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1) + + using bits_type = typename std::conditional::type; + + const auto bits = static_cast(reinterpret_bits(value)); + const std::uint64_t E = bits >> (kPrecision - 1); + const std::uint64_t F = bits & (kHiddenBit - 1); + + const bool is_denormal = E == 0; + const diyfp v = is_denormal + ? diyfp(F, kMinExp) + : diyfp(F + kHiddenBit, static_cast(E) - kBias); + + // Compute the boundaries m- and m+ of the floating-point value + // v = f * 2^e. + // + // Determine v- and v+, the floating-point predecessor and successor if v, + // respectively. + // + // v- = v - 2^e if f != 2^(p-1) or e == e_min (A) + // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B) + // + // v+ = v + 2^e + // + // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_ + // between m- and m+ round to v, regardless of how the input rounding + // algorithm breaks ties. + // + // ---+-------------+-------------+-------------+-------------+--- (A) + // v- m- v m+ v+ + // + // -----------------+------+------+-------------+-------------+--- (B) + // v- m- v m+ v+ + + const bool lower_boundary_is_closer = F == 0 && E > 1; + const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1); + const diyfp m_minus = lower_boundary_is_closer + ? diyfp(4 * v.f - 1, v.e - 2) // (B) + : diyfp(2 * v.f - 1, v.e - 1); // (A) + + // Determine the normalized w+ = m+. + const diyfp w_plus = diyfp::normalize(m_plus); + + // Determine w- = m- such that e_(w-) = e_(w+). + const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e); + + return {diyfp::normalize(v), w_minus, w_plus}; +} + +// Given normalized diyfp w, Grisu needs to find a (normalized) cached +// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies +// within a certain range [alpha, gamma] (Definition 3.2 from [1]) +// +// alpha <= e = e_c + e_w + q <= gamma +// +// or +// +// f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q +// <= f_c * f_w * 2^gamma +// +// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies +// +// 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma +// +// or +// +// 2^(q - 2 + alpha) <= c * w < 2^(q + gamma) +// +// The choice of (alpha,gamma) determines the size of the table and the form of +// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well +// in practice: +// +// The idea is to cut the number c * w = f * 2^e into two parts, which can be +// processed independently: An integral part p1, and a fractional part p2: +// +// f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e +// = (f div 2^-e) + (f mod 2^-e) * 2^e +// = p1 + p2 * 2^e +// +// The conversion of p1 into decimal form requires a series of divisions and +// modulos by (a power of) 10. These operations are faster for 32-bit than for +// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be +// achieved by choosing +// +// -e >= 32 or e <= -32 := gamma +// +// In order to convert the fractional part +// +// p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ... +// +// into decimal form, the fraction is repeatedly multiplied by 10 and the digits +// d[-i] are extracted in order: +// +// (10 * p2) div 2^-e = d[-1] +// (10 * p2) mod 2^-e = d[-2] / 10^1 + ... +// +// The multiplication by 10 must not overflow. It is sufficient to choose +// +// 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64. +// +// Since p2 = f mod 2^-e < 2^-e, +// +// -e <= 60 or e >= -60 := alpha + +constexpr int kAlpha = -60; +constexpr int kGamma = -32; + +struct cached_power // c = f * 2^e ~= 10^k +{ + std::uint64_t f; + int e; + int k; +}; + +/*! +For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached +power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c +satisfies (Definition 3.2 from [1]) + + alpha <= e_c + e + q <= gamma. +*/ +inline cached_power get_cached_power_for_binary_exponent(int e) +{ + // Now + // + // alpha <= e_c + e + q <= gamma (1) + // ==> f_c * 2^alpha <= c * 2^e * 2^q + // + // and since the c's are normalized, 2^(q-1) <= f_c, + // + // ==> 2^(q - 1 + alpha) <= c * 2^(e + q) + // ==> 2^(alpha - e - 1) <= c + // + // If c were an exact power of ten, i.e. c = 10^k, one may determine k as + // + // k = ceil( log_10( 2^(alpha - e - 1) ) ) + // = ceil( (alpha - e - 1) * log_10(2) ) + // + // From the paper: + // "In theory the result of the procedure could be wrong since c is rounded, + // and the computation itself is approximated [...]. In practice, however, + // this simple function is sufficient." + // + // For IEEE double precision floating-point numbers converted into + // normalized diyfp's w = f * 2^e, with q = 64, + // + // e >= -1022 (min IEEE exponent) + // -52 (p - 1) + // -52 (p - 1, possibly normalize denormal IEEE numbers) + // -11 (normalize the diyfp) + // = -1137 + // + // and + // + // e <= +1023 (max IEEE exponent) + // -52 (p - 1) + // -11 (normalize the diyfp) + // = 960 + // + // This binary exponent range [-1137,960] results in a decimal exponent + // range [-307,324]. One does not need to store a cached power for each + // k in this range. For each such k it suffices to find a cached power + // such that the exponent of the product lies in [alpha,gamma]. + // This implies that the difference of the decimal exponents of adjacent + // table entries must be less than or equal to + // + // floor( (gamma - alpha) * log_10(2) ) = 8. + // + // (A smaller distance gamma-alpha would require a larger table.) + + // NB: + // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34. + + constexpr int kCachedPowersMinDecExp = -300; + constexpr int kCachedPowersDecStep = 8; + + static constexpr std::array kCachedPowers = + { + { + { 0xAB70FE17C79AC6CA, -1060, -300 }, + { 0xFF77B1FCBEBCDC4F, -1034, -292 }, + { 0xBE5691EF416BD60C, -1007, -284 }, + { 0x8DD01FAD907FFC3C, -980, -276 }, + { 0xD3515C2831559A83, -954, -268 }, + { 0x9D71AC8FADA6C9B5, -927, -260 }, + { 0xEA9C227723EE8BCB, -901, -252 }, + { 0xAECC49914078536D, -874, -244 }, + { 0x823C12795DB6CE57, -847, -236 }, + { 0xC21094364DFB5637, -821, -228 }, + { 0x9096EA6F3848984F, -794, -220 }, + { 0xD77485CB25823AC7, -768, -212 }, + { 0xA086CFCD97BF97F4, -741, -204 }, + { 0xEF340A98172AACE5, -715, -196 }, + { 0xB23867FB2A35B28E, -688, -188 }, + { 0x84C8D4DFD2C63F3B, -661, -180 }, + { 0xC5DD44271AD3CDBA, -635, -172 }, + { 0x936B9FCEBB25C996, -608, -164 }, + { 0xDBAC6C247D62A584, -582, -156 }, + { 0xA3AB66580D5FDAF6, -555, -148 }, + { 0xF3E2F893DEC3F126, -529, -140 }, + { 0xB5B5ADA8AAFF80B8, -502, -132 }, + { 0x87625F056C7C4A8B, -475, -124 }, + { 0xC9BCFF6034C13053, -449, -116 }, + { 0x964E858C91BA2655, -422, -108 }, + { 0xDFF9772470297EBD, -396, -100 }, + { 0xA6DFBD9FB8E5B88F, -369, -92 }, + { 0xF8A95FCF88747D94, -343, -84 }, + { 0xB94470938FA89BCF, -316, -76 }, + { 0x8A08F0F8BF0F156B, -289, -68 }, + { 0xCDB02555653131B6, -263, -60 }, + { 0x993FE2C6D07B7FAC, -236, -52 }, + { 0xE45C10C42A2B3B06, -210, -44 }, + { 0xAA242499697392D3, -183, -36 }, + { 0xFD87B5F28300CA0E, -157, -28 }, + { 0xBCE5086492111AEB, -130, -20 }, + { 0x8CBCCC096F5088CC, -103, -12 }, + { 0xD1B71758E219652C, -77, -4 }, + { 0x9C40000000000000, -50, 4 }, + { 0xE8D4A51000000000, -24, 12 }, + { 0xAD78EBC5AC620000, 3, 20 }, + { 0x813F3978F8940984, 30, 28 }, + { 0xC097CE7BC90715B3, 56, 36 }, + { 0x8F7E32CE7BEA5C70, 83, 44 }, + { 0xD5D238A4ABE98068, 109, 52 }, + { 0x9F4F2726179A2245, 136, 60 }, + { 0xED63A231D4C4FB27, 162, 68 }, + { 0xB0DE65388CC8ADA8, 189, 76 }, + { 0x83C7088E1AAB65DB, 216, 84 }, + { 0xC45D1DF942711D9A, 242, 92 }, + { 0x924D692CA61BE758, 269, 100 }, + { 0xDA01EE641A708DEA, 295, 108 }, + { 0xA26DA3999AEF774A, 322, 116 }, + { 0xF209787BB47D6B85, 348, 124 }, + { 0xB454E4A179DD1877, 375, 132 }, + { 0x865B86925B9BC5C2, 402, 140 }, + { 0xC83553C5C8965D3D, 428, 148 }, + { 0x952AB45CFA97A0B3, 455, 156 }, + { 0xDE469FBD99A05FE3, 481, 164 }, + { 0xA59BC234DB398C25, 508, 172 }, + { 0xF6C69A72A3989F5C, 534, 180 }, + { 0xB7DCBF5354E9BECE, 561, 188 }, + { 0x88FCF317F22241E2, 588, 196 }, + { 0xCC20CE9BD35C78A5, 614, 204 }, + { 0x98165AF37B2153DF, 641, 212 }, + { 0xE2A0B5DC971F303A, 667, 220 }, + { 0xA8D9D1535CE3B396, 694, 228 }, + { 0xFB9B7CD9A4A7443C, 720, 236 }, + { 0xBB764C4CA7A44410, 747, 244 }, + { 0x8BAB8EEFB6409C1A, 774, 252 }, + { 0xD01FEF10A657842C, 800, 260 }, + { 0x9B10A4E5E9913129, 827, 268 }, + { 0xE7109BFBA19C0C9D, 853, 276 }, + { 0xAC2820D9623BF429, 880, 284 }, + { 0x80444B5E7AA7CF85, 907, 292 }, + { 0xBF21E44003ACDD2D, 933, 300 }, + { 0x8E679C2F5E44FF8F, 960, 308 }, + { 0xD433179D9C8CB841, 986, 316 }, + { 0x9E19DB92B4E31BA9, 1013, 324 }, + } + }; + + // This computation gives exactly the same results for k as + // k = ceil((kAlpha - e - 1) * 0.30102999566398114) + // for |e| <= 1500, but doesn't require floating-point operations. + // NB: log_10(2) ~= 78913 / 2^18 + JSON_ASSERT(e >= -1500); + JSON_ASSERT(e <= 1500); + const int f = kAlpha - e - 1; + const int k = (f * 78913) / (1 << 18) + static_cast(f > 0); + + const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep; + JSON_ASSERT(index >= 0); + JSON_ASSERT(static_cast(index) < kCachedPowers.size()); + + const cached_power cached = kCachedPowers[static_cast(index)]; + JSON_ASSERT(kAlpha <= cached.e + e + 64); + JSON_ASSERT(kGamma >= cached.e + e + 64); + + return cached; +} + +/*! +For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k. +For n == 0, returns 1 and sets pow10 := 1. +*/ +inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10) +{ + // LCOV_EXCL_START + if (n >= 1000000000) + { + pow10 = 1000000000; + return 10; + } + // LCOV_EXCL_STOP + if (n >= 100000000) + { + pow10 = 100000000; + return 9; + } + if (n >= 10000000) + { + pow10 = 10000000; + return 8; + } + if (n >= 1000000) + { + pow10 = 1000000; + return 7; + } + if (n >= 100000) + { + pow10 = 100000; + return 6; + } + if (n >= 10000) + { + pow10 = 10000; + return 5; + } + if (n >= 1000) + { + pow10 = 1000; + return 4; + } + if (n >= 100) + { + pow10 = 100; + return 3; + } + if (n >= 10) + { + pow10 = 10; + return 2; + } + + pow10 = 1; + return 1; +} + +inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta, + std::uint64_t rest, std::uint64_t ten_k) +{ + JSON_ASSERT(len >= 1); + JSON_ASSERT(dist <= delta); + JSON_ASSERT(rest <= delta); + JSON_ASSERT(ten_k > 0); + + // <--------------------------- delta ----> + // <---- dist ---------> + // --------------[------------------+-------------------]-------------- + // M- w M+ + // + // ten_k + // <------> + // <---- rest ----> + // --------------[------------------+----+--------------]-------------- + // w V + // = buf * 10^k + // + // ten_k represents a unit-in-the-last-place in the decimal representation + // stored in buf. + // Decrement buf by ten_k while this takes buf closer to w. + + // The tests are written in this order to avoid overflow in unsigned + // integer arithmetic. + + while (rest < dist + && delta - rest >= ten_k + && (rest + ten_k < dist || dist - rest > rest + ten_k - dist)) + { + JSON_ASSERT(buf[len - 1] != '0'); + buf[len - 1]--; + rest += ten_k; + } +} + +/*! +Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+. +M- and M+ must be normalized and share the same exponent -60 <= e <= -32. +*/ +inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent, + diyfp M_minus, diyfp w, diyfp M_plus) +{ + static_assert(kAlpha >= -60, "internal error"); + static_assert(kGamma <= -32, "internal error"); + + // Generates the digits (and the exponent) of a decimal floating-point + // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's + // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma. + // + // <--------------------------- delta ----> + // <---- dist ---------> + // --------------[------------------+-------------------]-------------- + // M- w M+ + // + // Grisu2 generates the digits of M+ from left to right and stops as soon as + // V is in [M-,M+]. + + JSON_ASSERT(M_plus.e >= kAlpha); + JSON_ASSERT(M_plus.e <= kGamma); + + std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e) + std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e) + + // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0): + // + // M+ = f * 2^e + // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e + // = ((p1 ) * 2^-e + (p2 )) * 2^e + // = p1 + p2 * 2^e + + const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e); + + auto p1 = static_cast(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.) + std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e + + // 1) + // + // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0] + + JSON_ASSERT(p1 > 0); + + std::uint32_t pow10{}; + const int k = find_largest_pow10(p1, pow10); + + // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1) + // + // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1)) + // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1)) + // + // M+ = p1 + p2 * 2^e + // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e + // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e + // = d[k-1] * 10^(k-1) + ( rest) * 2^e + // + // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0) + // + // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0] + // + // but stop as soon as + // + // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e + + int n = k; + while (n > 0) + { + // Invariants: + // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k) + // pow10 = 10^(n-1) <= p1 < 10^n + // + const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1) + const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1) + // + // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e + // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e) + // + JSON_ASSERT(d <= 9); + buffer[length++] = static_cast('0' + d); // buffer := buffer * 10 + d + // + // M+ = buffer * 10^(n-1) + (r + p2 * 2^e) + // + p1 = r; + n--; + // + // M+ = buffer * 10^n + (p1 + p2 * 2^e) + // pow10 = 10^n + // + + // Now check if enough digits have been generated. + // Compute + // + // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e + // + // Note: + // Since rest and delta share the same exponent e, it suffices to + // compare the significands. + const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2; + if (rest <= delta) + { + // V = buffer * 10^n, with M- <= V <= M+. + + decimal_exponent += n; + + // We may now just stop. But instead look if the buffer could be + // decremented to bring V closer to w. + // + // pow10 = 10^n is now 1 ulp in the decimal representation V. + // The rounding procedure works with diyfp's with an implicit + // exponent of e. + // + // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e + // + const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e; + grisu2_round(buffer, length, dist, delta, rest, ten_n); + + return; + } + + pow10 /= 10; + // + // pow10 = 10^(n-1) <= p1 < 10^n + // Invariants restored. + } + + // 2) + // + // The digits of the integral part have been generated: + // + // M+ = d[k-1]...d[1]d[0] + p2 * 2^e + // = buffer + p2 * 2^e + // + // Now generate the digits of the fractional part p2 * 2^e. + // + // Note: + // No decimal point is generated: the exponent is adjusted instead. + // + // p2 actually represents the fraction + // + // p2 * 2^e + // = p2 / 2^-e + // = d[-1] / 10^1 + d[-2] / 10^2 + ... + // + // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...) + // + // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m + // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...) + // + // using + // + // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e) + // = ( d) * 2^-e + ( r) + // + // or + // 10^m * p2 * 2^e = d + r * 2^e + // + // i.e. + // + // M+ = buffer + p2 * 2^e + // = buffer + 10^-m * (d + r * 2^e) + // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e + // + // and stop as soon as 10^-m * r * 2^e <= delta * 2^e + + JSON_ASSERT(p2 > delta); + + int m = 0; + for (;;) + { + // Invariant: + // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e + // = buffer * 10^-m + 10^-m * (p2 ) * 2^e + // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e + // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e + // + JSON_ASSERT(p2 <= (std::numeric_limits::max)() / 10); + p2 *= 10; + const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e + const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e + // + // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e + // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e)) + // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e + // + JSON_ASSERT(d <= 9); + buffer[length++] = static_cast('0' + d); // buffer := buffer * 10 + d + // + // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e + // + p2 = r; + m++; + // + // M+ = buffer * 10^-m + 10^-m * p2 * 2^e + // Invariant restored. + + // Check if enough digits have been generated. + // + // 10^-m * p2 * 2^e <= delta * 2^e + // p2 * 2^e <= 10^m * delta * 2^e + // p2 <= 10^m * delta + delta *= 10; + dist *= 10; + if (p2 <= delta) + { + break; + } + } + + // V = buffer * 10^-m, with M- <= V <= M+. + + decimal_exponent -= m; + + // 1 ulp in the decimal representation is now 10^-m. + // Since delta and dist are now scaled by 10^m, we need to do the + // same with ulp in order to keep the units in sync. + // + // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e + // + const std::uint64_t ten_m = one.f; + grisu2_round(buffer, length, dist, delta, p2, ten_m); + + // By construction this algorithm generates the shortest possible decimal + // number (Loitsch, Theorem 6.2) which rounds back to w. + // For an input number of precision p, at least + // + // N = 1 + ceil(p * log_10(2)) + // + // decimal digits are sufficient to identify all binary floating-point + // numbers (Matula, "In-and-Out conversions"). + // This implies that the algorithm does not produce more than N decimal + // digits. + // + // N = 17 for p = 53 (IEEE double precision) + // N = 9 for p = 24 (IEEE single precision) +} + +/*! +v = buf * 10^decimal_exponent +len is the length of the buffer (number of decimal digits) +The buffer must be large enough, i.e. >= max_digits10. +*/ +JSON_HEDLEY_NON_NULL(1) +inline void grisu2(char* buf, int& len, int& decimal_exponent, + diyfp m_minus, diyfp v, diyfp m_plus) +{ + JSON_ASSERT(m_plus.e == m_minus.e); + JSON_ASSERT(m_plus.e == v.e); + + // --------(-----------------------+-----------------------)-------- (A) + // m- v m+ + // + // --------------------(-----------+-----------------------)-------- (B) + // m- v m+ + // + // First scale v (and m- and m+) such that the exponent is in the range + // [alpha, gamma]. + + const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e); + + const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k + + // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma] + const diyfp w = diyfp::mul(v, c_minus_k); + const diyfp w_minus = diyfp::mul(m_minus, c_minus_k); + const diyfp w_plus = diyfp::mul(m_plus, c_minus_k); + + // ----(---+---)---------------(---+---)---------------(---+---)---- + // w- w w+ + // = c*m- = c*v = c*m+ + // + // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and + // w+ are now off by a small amount. + // In fact: + // + // w - v * 10^k < 1 ulp + // + // To account for this inaccuracy, add resp. subtract 1 ulp. + // + // --------+---[---------------(---+---)---------------]---+-------- + // w- M- w M+ w+ + // + // Now any number in [M-, M+] (bounds included) will round to w when input, + // regardless of how the input rounding algorithm breaks ties. + // + // And digit_gen generates the shortest possible such number in [M-, M+]. + // Note that this does not mean that Grisu2 always generates the shortest + // possible number in the interval (m-, m+). + const diyfp M_minus(w_minus.f + 1, w_minus.e); + const diyfp M_plus (w_plus.f - 1, w_plus.e ); + + decimal_exponent = -cached.k; // = -(-k) = k + + grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus); +} + +/*! +v = buf * 10^decimal_exponent +len is the length of the buffer (number of decimal digits) +The buffer must be large enough, i.e. >= max_digits10. +*/ +template +JSON_HEDLEY_NON_NULL(1) +void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value) +{ + static_assert(diyfp::kPrecision >= std::numeric_limits::digits + 3, + "internal error: not enough precision"); + + JSON_ASSERT(std::isfinite(value)); + JSON_ASSERT(value > 0); + + // If the neighbors (and boundaries) of 'value' are always computed for double-precision + // numbers, all float's can be recovered using strtod (and strtof). However, the resulting + // decimal representations are not exactly "short". + // + // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars) + // says "value is converted to a string as if by std::sprintf in the default ("C") locale" + // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars' + // does. + // On the other hand, the documentation for 'std::to_chars' requires that "parsing the + // representation using the corresponding std::from_chars function recovers value exactly". That + // indicates that single precision floating-point numbers should be recovered using + // 'std::strtof'. + // + // NB: If the neighbors are computed for single-precision numbers, there is a single float + // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision + // value is off by 1 ulp. +#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if) + const boundaries w = compute_boundaries(static_cast(value)); +#else + const boundaries w = compute_boundaries(value); +#endif + + grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus); +} + +/*! +@brief appends a decimal representation of e to buf +@return a pointer to the element following the exponent. +@pre -1000 < e < 1000 +*/ +JSON_HEDLEY_NON_NULL(1) +JSON_HEDLEY_RETURNS_NON_NULL +inline char* append_exponent(char* buf, int e) +{ + JSON_ASSERT(e > -1000); + JSON_ASSERT(e < 1000); + + if (e < 0) + { + e = -e; + *buf++ = '-'; + } + else + { + *buf++ = '+'; + } + + auto k = static_cast(e); + if (k < 10) + { + // Always print at least two digits in the exponent. + // This is for compatibility with printf("%g"). + *buf++ = '0'; + *buf++ = static_cast('0' + k); + } + else if (k < 100) + { + *buf++ = static_cast('0' + k / 10); + k %= 10; + *buf++ = static_cast('0' + k); + } + else + { + *buf++ = static_cast('0' + k / 100); + k %= 100; + *buf++ = static_cast('0' + k / 10); + k %= 10; + *buf++ = static_cast('0' + k); + } + + return buf; +} + +/*! +@brief prettify v = buf * 10^decimal_exponent + +If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point +notation. Otherwise it will be printed in exponential notation. + +@pre min_exp < 0 +@pre max_exp > 0 +*/ +JSON_HEDLEY_NON_NULL(1) +JSON_HEDLEY_RETURNS_NON_NULL +inline char* format_buffer(char* buf, int len, int decimal_exponent, + int min_exp, int max_exp) +{ + JSON_ASSERT(min_exp < 0); + JSON_ASSERT(max_exp > 0); + + const int k = len; + const int n = len + decimal_exponent; + + // v = buf * 10^(n-k) + // k is the length of the buffer (number of decimal digits) + // n is the position of the decimal point relative to the start of the buffer. + + if (k <= n && n <= max_exp) + { + // digits[000] + // len <= max_exp + 2 + + std::memset(buf + k, '0', static_cast(n) - static_cast(k)); + // Make it look like a floating-point number (#362, #378) + buf[n + 0] = '.'; + buf[n + 1] = '0'; + return buf + (static_cast(n) + 2); + } + + if (0 < n && n <= max_exp) + { + // dig.its + // len <= max_digits10 + 1 + + JSON_ASSERT(k > n); + + std::memmove(buf + (static_cast(n) + 1), buf + n, static_cast(k) - static_cast(n)); + buf[n] = '.'; + return buf + (static_cast(k) + 1U); + } + + if (min_exp < n && n <= 0) + { + // 0.[000]digits + // len <= 2 + (-min_exp - 1) + max_digits10 + + std::memmove(buf + (2 + static_cast(-n)), buf, static_cast(k)); + buf[0] = '0'; + buf[1] = '.'; + std::memset(buf + 2, '0', static_cast(-n)); + return buf + (2U + static_cast(-n) + static_cast(k)); + } + + if (k == 1) + { + // dE+123 + // len <= 1 + 5 + + buf += 1; + } + else + { + // d.igitsE+123 + // len <= max_digits10 + 1 + 5 + + std::memmove(buf + 2, buf + 1, static_cast(k) - 1); + buf[1] = '.'; + buf += 1 + static_cast(k); + } + + *buf++ = 'e'; + return append_exponent(buf, n - 1); +} + +} // namespace dtoa_impl + +/*! +@brief generates a decimal representation of the floating-point number value in [first, last). + +The format of the resulting decimal representation is similar to printf's %g +format. Returns an iterator pointing past-the-end of the decimal representation. + +@note The input number must be finite, i.e. NaN's and Inf's are not supported. +@note The buffer must be large enough. +@note The result is NOT null-terminated. +*/ +template +JSON_HEDLEY_NON_NULL(1, 2) +JSON_HEDLEY_RETURNS_NON_NULL +char* to_chars(char* first, const char* last, FloatType value) +{ + static_cast(last); // maybe unused - fix warning + JSON_ASSERT(std::isfinite(value)); + + // Use signbit(value) instead of (value < 0) since signbit works for -0. + if (std::signbit(value)) + { + value = -value; + *first++ = '-'; + } + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wfloat-equal" +#endif + if (value == 0) // +-0 + { + *first++ = '0'; + // Make it look like a floating-point number (#362, #378) + *first++ = '.'; + *first++ = '0'; + return first; + } +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif + + JSON_ASSERT(last - first >= std::numeric_limits::max_digits10); + + // Compute v = buffer * 10^decimal_exponent. + // The decimal digits are stored in the buffer, which needs to be interpreted + // as an unsigned decimal integer. + // len is the length of the buffer, i.e. the number of decimal digits. + int len = 0; + int decimal_exponent = 0; + dtoa_impl::grisu2(first, len, decimal_exponent, value); + + JSON_ASSERT(len <= std::numeric_limits::max_digits10); + + // Format the buffer like printf("%.*g", prec, value) + constexpr int kMinExp = -4; + // Use digits10 here to increase compatibility with version 2. + constexpr int kMaxExp = std::numeric_limits::digits10; + + JSON_ASSERT(last - first >= kMaxExp + 2); + JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits::max_digits10); + JSON_ASSERT(last - first >= std::numeric_limits::max_digits10 + 6); + + return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_json.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_json.hpp new file mode 100644 index 0000000..e39b779 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/conversions/to_json.hpp @@ -0,0 +1,446 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // copy +#include // begin, end +#include // string +#include // tuple, get +#include // is_same, is_constructible, is_floating_point, is_enum, underlying_type +#include // move, forward, declval, pair +#include // valarray +#include // vector + +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +////////////////// +// constructors // +////////////////// + +/* + * Note all external_constructor<>::construct functions need to call + * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an + * allocated value (e.g., a string). See bug issue + * https://github.com/nlohmann/json/issues/2865 for more information. + */ + +template struct external_constructor; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::boolean; + j.m_data.m_value = b; + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::string; + j.m_data.m_value = s; + j.assert_invariant(); + } + + template + static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::string; + j.m_data.m_value = std::move(s); + j.assert_invariant(); + } + + template < typename BasicJsonType, typename CompatibleStringType, + enable_if_t < !std::is_same::value, + int > = 0 > + static void construct(BasicJsonType& j, const CompatibleStringType& str) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::string; + j.m_data.m_value.string = j.template create(str); + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::binary; + j.m_data.m_value = typename BasicJsonType::binary_t(b); + j.assert_invariant(); + } + + template + static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::binary; + j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b)); + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::number_float; + j.m_data.m_value = val; + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::number_unsigned; + j.m_data.m_value = val; + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::number_integer; + j.m_data.m_value = val; + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::array; + j.m_data.m_value = arr; + j.set_parents(); + j.assert_invariant(); + } + + template + static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::array; + j.m_data.m_value = std::move(arr); + j.set_parents(); + j.assert_invariant(); + } + + template < typename BasicJsonType, typename CompatibleArrayType, + enable_if_t < !std::is_same::value, + int > = 0 > + static void construct(BasicJsonType& j, const CompatibleArrayType& arr) + { + using std::begin; + using std::end; + + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::array; + j.m_data.m_value.array = j.template create(begin(arr), end(arr)); + j.set_parents(); + j.assert_invariant(); + } + + template + static void construct(BasicJsonType& j, const std::vector& arr) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::array; + j.m_data.m_value = value_t::array; + j.m_data.m_value.array->reserve(arr.size()); + for (const bool x : arr) + { + j.m_data.m_value.array->push_back(x); + j.set_parent(j.m_data.m_value.array->back()); + } + j.assert_invariant(); + } + + template::value, int> = 0> + static void construct(BasicJsonType& j, const std::valarray& arr) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::array; + j.m_data.m_value = value_t::array; + j.m_data.m_value.array->resize(arr.size()); + if (arr.size() > 0) + { + std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin()); + } + j.set_parents(); + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::object; + j.m_data.m_value = obj; + j.set_parents(); + j.assert_invariant(); + } + + template + static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj) + { + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::object; + j.m_data.m_value = std::move(obj); + j.set_parents(); + j.assert_invariant(); + } + + template < typename BasicJsonType, typename CompatibleObjectType, + enable_if_t < !std::is_same::value, int > = 0 > + static void construct(BasicJsonType& j, const CompatibleObjectType& obj) + { + using std::begin; + using std::end; + + j.m_data.m_value.destroy(j.m_data.m_type); + j.m_data.m_type = value_t::object; + j.m_data.m_value.object = j.template create(begin(obj), end(obj)); + j.set_parents(); + j.assert_invariant(); + } +}; + +///////////// +// to_json // +///////////// + +template::value, int> = 0> +inline void to_json(BasicJsonType& j, T b) noexcept +{ + external_constructor::construct(j, b); +} + +template < typename BasicJsonType, typename BoolRef, + enable_if_t < + ((std::is_same::reference, BoolRef>::value + && !std::is_same ::reference, typename BasicJsonType::boolean_t&>::value) + || (std::is_same::const_reference, BoolRef>::value + && !std::is_same ::const_reference>, + typename BasicJsonType::boolean_t >::value)) + && std::is_convertible::value, int > = 0 > +inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept +{ + external_constructor::construct(j, static_cast(b)); +} + +template::value, int> = 0> +inline void to_json(BasicJsonType& j, const CompatibleString& s) +{ + external_constructor::construct(j, s); +} + +template +inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s) +{ + external_constructor::construct(j, std::move(s)); +} + +template::value, int> = 0> +inline void to_json(BasicJsonType& j, FloatType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template::value, int> = 0> +inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template::value, int> = 0> +inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +#if !JSON_DISABLE_ENUM_SERIALIZATION +template::value, int> = 0> +inline void to_json(BasicJsonType& j, EnumType e) noexcept +{ + using underlying_type = typename std::underlying_type::type; + external_constructor::construct(j, static_cast(e)); +} +#endif // JSON_DISABLE_ENUM_SERIALIZATION + +template +inline void to_json(BasicJsonType& j, const std::vector& e) +{ + external_constructor::construct(j, e); +} + +template < typename BasicJsonType, typename CompatibleArrayType, + enable_if_t < is_compatible_array_type::value&& + !is_compatible_object_type::value&& + !is_compatible_string_type::value&& + !std::is_same::value&& + !is_basic_json::value, + int > = 0 > +inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr) +{ + external_constructor::construct(j, arr); +} + +template +inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin) +{ + external_constructor::construct(j, bin); +} + +template::value, int> = 0> +inline void to_json(BasicJsonType& j, const std::valarray& arr) +{ + external_constructor::construct(j, std::move(arr)); +} + +template +inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr) +{ + external_constructor::construct(j, std::move(arr)); +} + +template < typename BasicJsonType, typename CompatibleObjectType, + enable_if_t < is_compatible_object_type::value&& !is_basic_json::value, int > = 0 > +inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj) +{ + external_constructor::construct(j, obj); +} + +template +inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj) +{ + external_constructor::construct(j, std::move(obj)); +} + +template < + typename BasicJsonType, typename T, std::size_t N, + enable_if_t < !std::is_constructible::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) + int > = 0 > +inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) +{ + external_constructor::construct(j, arr); +} + +template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible::value&& std::is_constructible::value, int > = 0 > +inline void to_json(BasicJsonType& j, const std::pair& p) +{ + j = { p.first, p.second }; +} + +// for https://github.com/nlohmann/json/pull/1134 +template>::value, int> = 0> +inline void to_json(BasicJsonType& j, const T& b) +{ + j = { {b.key(), b.value()} }; +} + +template +inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence /*unused*/) +{ + j = { std::get(t)... }; +} + +template::value, int > = 0> +inline void to_json(BasicJsonType& j, const T& t) +{ + to_json_tuple_impl(j, t, make_index_sequence::value> {}); +} + +#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM +template +inline void to_json(BasicJsonType& j, const std_fs::path& p) +{ + j = p.string(); +} +#endif + +struct to_json_fn +{ + template + auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward(val)))) + -> decltype(to_json(j, std::forward(val)), void()) + { + return to_json(j, std::forward(val)); + } +}; +} // namespace detail + +#ifndef JSON_HAS_CPP_17 +/// namespace to hold default `to_json` function +/// to see why this is required: +/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html +namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces) +{ +#endif +JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers) + detail::static_const::value; +#ifndef JSON_HAS_CPP_17 +} // namespace +#endif + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/exceptions.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/exceptions.hpp new file mode 100644 index 0000000..5974d7b --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/exceptions.hpp @@ -0,0 +1,257 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +#include +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +//////////////// +// exceptions // +//////////////// + +/// @brief general exception of the @ref basic_json class +/// @sa https://json.nlohmann.me/api/basic_json/exception/ +class exception : public std::exception +{ + public: + /// returns the explanatory string + const char* what() const noexcept override + { + return m.what(); + } + + /// the id of the exception + const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes) + + protected: + JSON_HEDLEY_NON_NULL(3) + exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing) + + static std::string name(const std::string& ename, int id_) + { + return concat("[json.exception.", ename, '.', std::to_string(id_), "] "); + } + + static std::string diagnostics(std::nullptr_t /*leaf_element*/) + { + return ""; + } + + template + static std::string diagnostics(const BasicJsonType* leaf_element) + { +#if JSON_DIAGNOSTICS + std::vector tokens; + for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent) + { + switch (current->m_parent->type()) + { + case value_t::array: + { + for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i) + { + if (¤t->m_parent->m_data.m_value.array->operator[](i) == current) + { + tokens.emplace_back(std::to_string(i)); + break; + } + } + break; + } + + case value_t::object: + { + for (const auto& element : *current->m_parent->m_data.m_value.object) + { + if (&element.second == current) + { + tokens.emplace_back(element.first.c_str()); + break; + } + } + break; + } + + case value_t::null: // LCOV_EXCL_LINE + case value_t::string: // LCOV_EXCL_LINE + case value_t::boolean: // LCOV_EXCL_LINE + case value_t::number_integer: // LCOV_EXCL_LINE + case value_t::number_unsigned: // LCOV_EXCL_LINE + case value_t::number_float: // LCOV_EXCL_LINE + case value_t::binary: // LCOV_EXCL_LINE + case value_t::discarded: // LCOV_EXCL_LINE + default: // LCOV_EXCL_LINE + break; // LCOV_EXCL_LINE + } + } + + if (tokens.empty()) + { + return ""; + } + + auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{}, + [](const std::string & a, const std::string & b) + { + return concat(a, '/', detail::escape(b)); + }); + return concat('(', str, ") "); +#else + static_cast(leaf_element); + return ""; +#endif + } + + private: + /// an exception object as storage for error messages + std::runtime_error m; +}; + +/// @brief exception indicating a parse error +/// @sa https://json.nlohmann.me/api/basic_json/parse_error/ +class parse_error : public exception +{ + public: + /*! + @brief create a parse error exception + @param[in] id_ the id of the exception + @param[in] pos the position where the error occurred (or with + chars_read_total=0 if the position cannot be + determined) + @param[in] what_arg the explanatory string + @return parse_error object + */ + template::value, int> = 0> + static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context) + { + const std::string w = concat(exception::name("parse_error", id_), "parse error", + position_string(pos), ": ", exception::diagnostics(context), what_arg); + return {id_, pos.chars_read_total, w.c_str()}; + } + + template::value, int> = 0> + static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context) + { + const std::string w = concat(exception::name("parse_error", id_), "parse error", + (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""), + ": ", exception::diagnostics(context), what_arg); + return {id_, byte_, w.c_str()}; + } + + /*! + @brief byte index of the parse error + + The byte index of the last read character in the input file. + + @note For an input with n bytes, 1 is the index of the first character and + n+1 is the index of the terminating null byte or the end of file. + This also holds true when reading a byte vector (CBOR or MessagePack). + */ + const std::size_t byte; + + private: + parse_error(int id_, std::size_t byte_, const char* what_arg) + : exception(id_, what_arg), byte(byte_) {} + + static std::string position_string(const position_t& pos) + { + return concat(" at line ", std::to_string(pos.lines_read + 1), + ", column ", std::to_string(pos.chars_read_current_line)); + } +}; + +/// @brief exception indicating errors with iterators +/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/ +class invalid_iterator : public exception +{ + public: + template::value, int> = 0> + static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context) + { + const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg); + return {id_, w.c_str()}; + } + + private: + JSON_HEDLEY_NON_NULL(3) + invalid_iterator(int id_, const char* what_arg) + : exception(id_, what_arg) {} +}; + +/// @brief exception indicating executing a member function with a wrong type +/// @sa https://json.nlohmann.me/api/basic_json/type_error/ +class type_error : public exception +{ + public: + template::value, int> = 0> + static type_error create(int id_, const std::string& what_arg, BasicJsonContext context) + { + const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg); + return {id_, w.c_str()}; + } + + private: + JSON_HEDLEY_NON_NULL(3) + type_error(int id_, const char* what_arg) : exception(id_, what_arg) {} +}; + +/// @brief exception indicating access out of the defined range +/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/ +class out_of_range : public exception +{ + public: + template::value, int> = 0> + static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context) + { + const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg); + return {id_, w.c_str()}; + } + + private: + JSON_HEDLEY_NON_NULL(3) + out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {} +}; + +/// @brief exception indicating other library errors +/// @sa https://json.nlohmann.me/api/basic_json/other_error/ +class other_error : public exception +{ + public: + template::value, int> = 0> + static other_error create(int id_, const std::string& what_arg, BasicJsonContext context) + { + const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg); + return {id_, w.c_str()}; + } + + private: + JSON_HEDLEY_NON_NULL(3) + other_error(int id_, const char* what_arg) : exception(id_, what_arg) {} +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/hash.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/hash.hpp new file mode 100644 index 0000000..4464e8e --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/hash.hpp @@ -0,0 +1,129 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // uint8_t +#include // size_t +#include // hash + +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// boost::hash_combine +inline std::size_t combine(std::size_t seed, std::size_t h) noexcept +{ + seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U); + return seed; +} + +/*! +@brief hash a JSON value + +The hash function tries to rely on std::hash where possible. Furthermore, the +type of the JSON value is taken into account to have different hash values for +null, 0, 0U, and false, etc. + +@tparam BasicJsonType basic_json specialization +@param j JSON value to hash +@return hash value of j +*/ +template +std::size_t hash(const BasicJsonType& j) +{ + using string_t = typename BasicJsonType::string_t; + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + + const auto type = static_cast(j.type()); + switch (j.type()) + { + case BasicJsonType::value_t::null: + case BasicJsonType::value_t::discarded: + { + return combine(type, 0); + } + + case BasicJsonType::value_t::object: + { + auto seed = combine(type, j.size()); + for (const auto& element : j.items()) + { + const auto h = std::hash {}(element.key()); + seed = combine(seed, h); + seed = combine(seed, hash(element.value())); + } + return seed; + } + + case BasicJsonType::value_t::array: + { + auto seed = combine(type, j.size()); + for (const auto& element : j) + { + seed = combine(seed, hash(element)); + } + return seed; + } + + case BasicJsonType::value_t::string: + { + const auto h = std::hash {}(j.template get_ref()); + return combine(type, h); + } + + case BasicJsonType::value_t::boolean: + { + const auto h = std::hash {}(j.template get()); + return combine(type, h); + } + + case BasicJsonType::value_t::number_integer: + { + const auto h = std::hash {}(j.template get()); + return combine(type, h); + } + + case BasicJsonType::value_t::number_unsigned: + { + const auto h = std::hash {}(j.template get()); + return combine(type, h); + } + + case BasicJsonType::value_t::number_float: + { + const auto h = std::hash {}(j.template get()); + return combine(type, h); + } + + case BasicJsonType::value_t::binary: + { + auto seed = combine(type, j.get_binary().size()); + const auto h = std::hash {}(j.get_binary().has_subtype()); + seed = combine(seed, h); + seed = combine(seed, static_cast(j.get_binary().subtype())); + for (const auto byte : j.get_binary()) + { + seed = combine(seed, std::hash {}(byte)); + } + return seed; + } + + default: // LCOV_EXCL_LINE + JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE + return 0; // LCOV_EXCL_LINE + } +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/binary_reader.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/binary_reader.hpp new file mode 100644 index 0000000..a6e100e --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/binary_reader.hpp @@ -0,0 +1,3009 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // generate_n +#include // array +#include // ldexp +#include // size_t +#include // uint8_t, uint16_t, uint32_t, uint64_t +#include // snprintf +#include // memcpy +#include // back_inserter +#include // numeric_limits +#include // char_traits, string +#include // make_pair, move +#include // vector + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// how to treat CBOR tags +enum class cbor_tag_handler_t +{ + error, ///< throw a parse_error exception in case of a tag + ignore, ///< ignore tags + store ///< store tags as binary type +}; + +/*! +@brief determine system byte order + +@return true if and only if system's byte order is little endian + +@note from https://stackoverflow.com/a/1001328/266378 +*/ +static inline bool little_endianness(int num = 1) noexcept +{ + return *reinterpret_cast(&num) == 1; +} + +/////////////////// +// binary reader // +/////////////////// + +/*! +@brief deserialization of CBOR, MessagePack, and UBJSON values +*/ +template> +class binary_reader +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + using json_sax_t = SAX; + using char_type = typename InputAdapterType::char_type; + using char_int_type = typename char_traits::int_type; + + public: + /*! + @brief create a binary reader + + @param[in] adapter input adapter to read from + */ + explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format) + { + (void)detail::is_sax_static_asserts {}; + } + + // make class move-only + binary_reader(const binary_reader&) = delete; + binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + binary_reader& operator=(const binary_reader&) = delete; + binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + ~binary_reader() = default; + + /*! + @param[in] format the binary format to parse + @param[in] sax_ a SAX event processor + @param[in] strict whether to expect the input to be consumed completed + @param[in] tag_handler how to treat CBOR tags + + @return whether parsing was successful + */ + JSON_HEDLEY_NON_NULL(3) + bool sax_parse(const input_format_t format, + json_sax_t* sax_, + const bool strict = true, + const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) + { + sax = sax_; + bool result = false; + + switch (format) + { + case input_format_t::bson: + result = parse_bson_internal(); + break; + + case input_format_t::cbor: + result = parse_cbor_internal(true, tag_handler); + break; + + case input_format_t::msgpack: + result = parse_msgpack_internal(); + break; + + case input_format_t::ubjson: + case input_format_t::bjdata: + result = parse_ubjson_internal(); + break; + + case input_format_t::json: // LCOV_EXCL_LINE + default: // LCOV_EXCL_LINE + JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE + } + + // strict mode: next byte must be EOF + if (result && strict) + { + if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata) + { + get_ignore_noop(); + } + else + { + get(); + } + + if (JSON_HEDLEY_UNLIKELY(current != char_traits::eof())) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read, + exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr)); + } + } + + return result; + } + + private: + ////////// + // BSON // + ////////// + + /*! + @brief Reads in a BSON-object and passes it to the SAX-parser. + @return whether a valid BSON-value was passed to the SAX parser + */ + bool parse_bson_internal() + { + std::int32_t document_size{}; + get_number(input_format_t::bson, document_size); + + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast(-1)))) + { + return false; + } + + if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false))) + { + return false; + } + + return sax->end_object(); + } + + /*! + @brief Parses a C-style string from the BSON input. + @param[in,out] result A reference to the string variable where the read + string is to be stored. + @return `true` if the \x00-byte indicating the end of the string was + encountered before the EOF; false` indicates an unexpected EOF. + */ + bool get_bson_cstr(string_t& result) + { + auto out = std::back_inserter(result); + while (true) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring"))) + { + return false; + } + if (current == 0x00) + { + return true; + } + *out++ = static_cast(current); + } + } + + /*! + @brief Parses a zero-terminated string of length @a len from the BSON + input. + @param[in] len The length (including the zero-byte at the end) of the + string to be read. + @param[in,out] result A reference to the string variable where the read + string is to be stored. + @tparam NumberType The type of the length @a len + @pre len >= 1 + @return `true` if the string was successfully parsed + */ + template + bool get_bson_string(const NumberType len, string_t& result) + { + if (JSON_HEDLEY_UNLIKELY(len < 1)) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr)); + } + + return get_string(input_format_t::bson, len - static_cast(1), result) && get() != char_traits::eof(); + } + + /*! + @brief Parses a byte array input of length @a len from the BSON input. + @param[in] len The length of the byte array to be read. + @param[in,out] result A reference to the binary variable where the read + array is to be stored. + @tparam NumberType The type of the length @a len + @pre len >= 0 + @return `true` if the byte array was successfully parsed + */ + template + bool get_bson_binary(const NumberType len, binary_t& result) + { + if (JSON_HEDLEY_UNLIKELY(len < 0)) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr)); + } + + // All BSON binary values have a subtype + std::uint8_t subtype{}; + get_number(input_format_t::bson, subtype); + result.set_subtype(subtype); + + return get_binary(input_format_t::bson, len, result); + } + + /*! + @brief Read a BSON document element of the given @a element_type. + @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html + @param[in] element_type_parse_position The position in the input stream, + where the `element_type` was read. + @warning Not all BSON element types are supported yet. An unsupported + @a element_type will give rise to a parse_error.114: + Unsupported BSON record type 0x... + @return whether a valid BSON-object/array was passed to the SAX parser + */ + bool parse_bson_element_internal(const char_int_type element_type, + const std::size_t element_type_parse_position) + { + switch (element_type) + { + case 0x01: // double + { + double number{}; + return get_number(input_format_t::bson, number) && sax->number_float(static_cast(number), ""); + } + + case 0x02: // string + { + std::int32_t len{}; + string_t value; + return get_number(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value); + } + + case 0x03: // object + { + return parse_bson_internal(); + } + + case 0x04: // array + { + return parse_bson_array(); + } + + case 0x05: // binary + { + std::int32_t len{}; + binary_t value; + return get_number(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value); + } + + case 0x08: // boolean + { + return sax->boolean(get() != 0); + } + + case 0x0A: // null + { + return sax->null(); + } + + case 0x10: // int32 + { + std::int32_t value{}; + return get_number(input_format_t::bson, value) && sax->number_integer(value); + } + + case 0x12: // int64 + { + std::int64_t value{}; + return get_number(input_format_t::bson, value) && sax->number_integer(value); + } + + default: // anything else not supported (yet) + { + std::array cr{{}}; + static_cast((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) + const std::string cr_str{cr.data()}; + return sax->parse_error(element_type_parse_position, cr_str, + parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr)); + } + } + } + + /*! + @brief Read a BSON element list (as specified in the BSON-spec) + + The same binary layout is used for objects and arrays, hence it must be + indicated with the argument @a is_array which one is expected + (true --> array, false --> object). + + @param[in] is_array Determines if the element list being read is to be + treated as an object (@a is_array == false), or as an + array (@a is_array == true). + @return whether a valid BSON-object/array was passed to the SAX parser + */ + bool parse_bson_element_list(const bool is_array) + { + string_t key; + + while (auto element_type = get()) + { + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list"))) + { + return false; + } + + const std::size_t element_type_parse_position = chars_read; + if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key))) + { + return false; + } + + if (!is_array && !sax->key(key)) + { + return false; + } + + if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position))) + { + return false; + } + + // get_bson_cstr only appends + key.clear(); + } + + return true; + } + + /*! + @brief Reads an array from the BSON input and passes it to the SAX-parser. + @return whether a valid BSON-array was passed to the SAX parser + */ + bool parse_bson_array() + { + std::int32_t document_size{}; + get_number(input_format_t::bson, document_size); + + if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast(-1)))) + { + return false; + } + + if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true))) + { + return false; + } + + return sax->end_array(); + } + + ////////// + // CBOR // + ////////// + + /*! + @param[in] get_char whether a new character should be retrieved from the + input (true) or whether the last read character should + be considered instead (false) + @param[in] tag_handler how CBOR tags should be treated + + @return whether a valid CBOR value was passed to the SAX parser + */ + bool parse_cbor_internal(const bool get_char, + const cbor_tag_handler_t tag_handler) + { + switch (get_char ? get() : current) + { + // EOF + case char_traits::eof(): + return unexpect_eof(input_format_t::cbor, "value"); + + // Integer 0x00..0x17 (0..23) + case 0x00: + case 0x01: + case 0x02: + case 0x03: + case 0x04: + case 0x05: + case 0x06: + case 0x07: + case 0x08: + case 0x09: + case 0x0A: + case 0x0B: + case 0x0C: + case 0x0D: + case 0x0E: + case 0x0F: + case 0x10: + case 0x11: + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + return sax->number_unsigned(static_cast(current)); + + case 0x18: // Unsigned integer (one-byte uint8_t follows) + { + std::uint8_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); + } + + case 0x19: // Unsigned integer (two-byte uint16_t follows) + { + std::uint16_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); + } + + case 0x1A: // Unsigned integer (four-byte uint32_t follows) + { + std::uint32_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); + } + + case 0x1B: // Unsigned integer (eight-byte uint64_t follows) + { + std::uint64_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); + } + + // Negative integer -1-0x00..-1-0x17 (-1..-24) + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + case 0x28: + case 0x29: + case 0x2A: + case 0x2B: + case 0x2C: + case 0x2D: + case 0x2E: + case 0x2F: + case 0x30: + case 0x31: + case 0x32: + case 0x33: + case 0x34: + case 0x35: + case 0x36: + case 0x37: + return sax->number_integer(static_cast(0x20 - 1 - current)); + + case 0x38: // Negative integer (one-byte uint8_t follows) + { + std::uint8_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast(-1) - number); + } + + case 0x39: // Negative integer -1-n (two-byte uint16_t follows) + { + std::uint16_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast(-1) - number); + } + + case 0x3A: // Negative integer -1-n (four-byte uint32_t follows) + { + std::uint32_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast(-1) - number); + } + + case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows) + { + std::uint64_t number{}; + return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast(-1) + - static_cast(number)); + } + + // Binary data (0x00..0x17 bytes follow) + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4A: + case 0x4B: + case 0x4C: + case 0x4D: + case 0x4E: + case 0x4F: + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + case 0x58: // Binary data (one-byte uint8_t for n follows) + case 0x59: // Binary data (two-byte uint16_t for n follow) + case 0x5A: // Binary data (four-byte uint32_t for n follow) + case 0x5B: // Binary data (eight-byte uint64_t for n follow) + case 0x5F: // Binary data (indefinite length) + { + binary_t b; + return get_cbor_binary(b) && sax->binary(b); + } + + // UTF-8 string (0x00..0x17 bytes follow) + case 0x60: + case 0x61: + case 0x62: + case 0x63: + case 0x64: + case 0x65: + case 0x66: + case 0x67: + case 0x68: + case 0x69: + case 0x6A: + case 0x6B: + case 0x6C: + case 0x6D: + case 0x6E: + case 0x6F: + case 0x70: + case 0x71: + case 0x72: + case 0x73: + case 0x74: + case 0x75: + case 0x76: + case 0x77: + case 0x78: // UTF-8 string (one-byte uint8_t for n follows) + case 0x79: // UTF-8 string (two-byte uint16_t for n follow) + case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) + case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) + case 0x7F: // UTF-8 string (indefinite length) + { + string_t s; + return get_cbor_string(s) && sax->string(s); + } + + // array (0x00..0x17 data items follow) + case 0x80: + case 0x81: + case 0x82: + case 0x83: + case 0x84: + case 0x85: + case 0x86: + case 0x87: + case 0x88: + case 0x89: + case 0x8A: + case 0x8B: + case 0x8C: + case 0x8D: + case 0x8E: + case 0x8F: + case 0x90: + case 0x91: + case 0x92: + case 0x93: + case 0x94: + case 0x95: + case 0x96: + case 0x97: + return get_cbor_array( + conditional_static_cast(static_cast(current) & 0x1Fu), tag_handler); + + case 0x98: // array (one-byte uint8_t for n follows) + { + std::uint8_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast(len), tag_handler); + } + + case 0x99: // array (two-byte uint16_t for n follow) + { + std::uint16_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast(len), tag_handler); + } + + case 0x9A: // array (four-byte uint32_t for n follow) + { + std::uint32_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast(len), tag_handler); + } + + case 0x9B: // array (eight-byte uint64_t for n follow) + { + std::uint64_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast(len), tag_handler); + } + + case 0x9F: // array (indefinite length) + return get_cbor_array(static_cast(-1), tag_handler); + + // map (0x00..0x17 pairs of data items follow) + case 0xA0: + case 0xA1: + case 0xA2: + case 0xA3: + case 0xA4: + case 0xA5: + case 0xA6: + case 0xA7: + case 0xA8: + case 0xA9: + case 0xAA: + case 0xAB: + case 0xAC: + case 0xAD: + case 0xAE: + case 0xAF: + case 0xB0: + case 0xB1: + case 0xB2: + case 0xB3: + case 0xB4: + case 0xB5: + case 0xB6: + case 0xB7: + return get_cbor_object(conditional_static_cast(static_cast(current) & 0x1Fu), tag_handler); + + case 0xB8: // map (one-byte uint8_t for n follows) + { + std::uint8_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast(len), tag_handler); + } + + case 0xB9: // map (two-byte uint16_t for n follow) + { + std::uint16_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast(len), tag_handler); + } + + case 0xBA: // map (four-byte uint32_t for n follow) + { + std::uint32_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast(len), tag_handler); + } + + case 0xBB: // map (eight-byte uint64_t for n follow) + { + std::uint64_t len{}; + return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast(len), tag_handler); + } + + case 0xBF: // map (indefinite length) + return get_cbor_object(static_cast(-1), tag_handler); + + case 0xC6: // tagged item + case 0xC7: + case 0xC8: + case 0xC9: + case 0xCA: + case 0xCB: + case 0xCC: + case 0xCD: + case 0xCE: + case 0xCF: + case 0xD0: + case 0xD1: + case 0xD2: + case 0xD3: + case 0xD4: + case 0xD8: // tagged item (1 bytes follow) + case 0xD9: // tagged item (2 bytes follow) + case 0xDA: // tagged item (4 bytes follow) + case 0xDB: // tagged item (8 bytes follow) + { + switch (tag_handler) + { + case cbor_tag_handler_t::error: + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); + } + + case cbor_tag_handler_t::ignore: + { + // ignore binary subtype + switch (current) + { + case 0xD8: + { + std::uint8_t subtype_to_ignore{}; + get_number(input_format_t::cbor, subtype_to_ignore); + break; + } + case 0xD9: + { + std::uint16_t subtype_to_ignore{}; + get_number(input_format_t::cbor, subtype_to_ignore); + break; + } + case 0xDA: + { + std::uint32_t subtype_to_ignore{}; + get_number(input_format_t::cbor, subtype_to_ignore); + break; + } + case 0xDB: + { + std::uint64_t subtype_to_ignore{}; + get_number(input_format_t::cbor, subtype_to_ignore); + break; + } + default: + break; + } + return parse_cbor_internal(true, tag_handler); + } + + case cbor_tag_handler_t::store: + { + binary_t b; + // use binary subtype and store in binary container + switch (current) + { + case 0xD8: + { + std::uint8_t subtype{}; + get_number(input_format_t::cbor, subtype); + b.set_subtype(detail::conditional_static_cast(subtype)); + break; + } + case 0xD9: + { + std::uint16_t subtype{}; + get_number(input_format_t::cbor, subtype); + b.set_subtype(detail::conditional_static_cast(subtype)); + break; + } + case 0xDA: + { + std::uint32_t subtype{}; + get_number(input_format_t::cbor, subtype); + b.set_subtype(detail::conditional_static_cast(subtype)); + break; + } + case 0xDB: + { + std::uint64_t subtype{}; + get_number(input_format_t::cbor, subtype); + b.set_subtype(detail::conditional_static_cast(subtype)); + break; + } + default: + return parse_cbor_internal(true, tag_handler); + } + get(); + return get_cbor_binary(b) && sax->binary(b); + } + + default: // LCOV_EXCL_LINE + JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE + return false; // LCOV_EXCL_LINE + } + } + + case 0xF4: // false + return sax->boolean(false); + + case 0xF5: // true + return sax->boolean(true); + + case 0xF6: // null + return sax->null(); + + case 0xF9: // Half-Precision Float (two-byte IEEE 754) + { + const auto byte1_raw = get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) + { + return false; + } + const auto byte2_raw = get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) + { + return false; + } + + const auto byte1 = static_cast(byte1_raw); + const auto byte2 = static_cast(byte2_raw); + + // code from RFC 7049, Appendix D, Figure 3: + // As half-precision floating-point numbers were only added + // to IEEE 754 in 2008, today's programming platforms often + // still only have limited support for them. It is very + // easy to include at least decoding support for them even + // without such support. An example of a small decoder for + // half-precision floating-point numbers in the C language + // is shown in Fig. 3. + const auto half = static_cast((byte1 << 8u) + byte2); + const double val = [&half] + { + const int exp = (half >> 10u) & 0x1Fu; + const unsigned int mant = half & 0x3FFu; + JSON_ASSERT(0 <= exp&& exp <= 32); + JSON_ASSERT(mant <= 1024); + switch (exp) + { + case 0: + return std::ldexp(mant, -24); + case 31: + return (mant == 0) + ? std::numeric_limits::infinity() + : std::numeric_limits::quiet_NaN(); + default: + return std::ldexp(mant + 1024, exp - 25); + } + }(); + return sax->number_float((half & 0x8000u) != 0 + ? static_cast(-val) + : static_cast(val), ""); + } + + case 0xFA: // Single-Precision Float (four-byte IEEE 754) + { + float number{}; + return get_number(input_format_t::cbor, number) && sax->number_float(static_cast(number), ""); + } + + case 0xFB: // Double-Precision Float (eight-byte IEEE 754) + { + double number{}; + return get_number(input_format_t::cbor, number) && sax->number_float(static_cast(number), ""); + } + + default: // anything else (0xFF is handled inside the other types) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); + } + } + } + + /*! + @brief reads a CBOR string + + This function first reads starting bytes to determine the expected + string length and then copies this number of bytes into a string. + Additionally, CBOR's strings with indefinite lengths are supported. + + @param[out] result created string + + @return whether string creation completed + */ + bool get_cbor_string(string_t& result) + { + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string"))) + { + return false; + } + + switch (current) + { + // UTF-8 string (0x00..0x17 bytes follow) + case 0x60: + case 0x61: + case 0x62: + case 0x63: + case 0x64: + case 0x65: + case 0x66: + case 0x67: + case 0x68: + case 0x69: + case 0x6A: + case 0x6B: + case 0x6C: + case 0x6D: + case 0x6E: + case 0x6F: + case 0x70: + case 0x71: + case 0x72: + case 0x73: + case 0x74: + case 0x75: + case 0x76: + case 0x77: + { + return get_string(input_format_t::cbor, static_cast(current) & 0x1Fu, result); + } + + case 0x78: // UTF-8 string (one-byte uint8_t for n follows) + { + std::uint8_t len{}; + return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + } + + case 0x79: // UTF-8 string (two-byte uint16_t for n follow) + { + std::uint16_t len{}; + return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + } + + case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) + { + std::uint32_t len{}; + return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + } + + case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) + { + std::uint64_t len{}; + return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + } + + case 0x7F: // UTF-8 string (indefinite length) + { + while (get() != 0xFF) + { + string_t chunk; + if (!get_cbor_string(chunk)) + { + return false; + } + result.append(chunk); + } + return true; + } + + default: + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, + exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr)); + } + } + } + + /*! + @brief reads a CBOR byte array + + This function first reads starting bytes to determine the expected + byte array length and then copies this number of bytes into the byte array. + Additionally, CBOR's byte arrays with indefinite lengths are supported. + + @param[out] result created byte array + + @return whether byte array creation completed + */ + bool get_cbor_binary(binary_t& result) + { + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary"))) + { + return false; + } + + switch (current) + { + // Binary data (0x00..0x17 bytes follow) + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4A: + case 0x4B: + case 0x4C: + case 0x4D: + case 0x4E: + case 0x4F: + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + { + return get_binary(input_format_t::cbor, static_cast(current) & 0x1Fu, result); + } + + case 0x58: // Binary data (one-byte uint8_t for n follows) + { + std::uint8_t len{}; + return get_number(input_format_t::cbor, len) && + get_binary(input_format_t::cbor, len, result); + } + + case 0x59: // Binary data (two-byte uint16_t for n follow) + { + std::uint16_t len{}; + return get_number(input_format_t::cbor, len) && + get_binary(input_format_t::cbor, len, result); + } + + case 0x5A: // Binary data (four-byte uint32_t for n follow) + { + std::uint32_t len{}; + return get_number(input_format_t::cbor, len) && + get_binary(input_format_t::cbor, len, result); + } + + case 0x5B: // Binary data (eight-byte uint64_t for n follow) + { + std::uint64_t len{}; + return get_number(input_format_t::cbor, len) && + get_binary(input_format_t::cbor, len, result); + } + + case 0x5F: // Binary data (indefinite length) + { + while (get() != 0xFF) + { + binary_t chunk; + if (!get_cbor_binary(chunk)) + { + return false; + } + result.insert(result.end(), chunk.begin(), chunk.end()); + } + return true; + } + + default: + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, + exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr)); + } + } + } + + /*! + @param[in] len the length of the array or static_cast(-1) for an + array of indefinite size + @param[in] tag_handler how CBOR tags should be treated + @return whether array creation completed + */ + bool get_cbor_array(const std::size_t len, + const cbor_tag_handler_t tag_handler) + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len))) + { + return false; + } + + if (len != static_cast(-1)) + { + for (std::size_t i = 0; i < len; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) + { + return false; + } + } + } + else + { + while (get() != 0xFF) + { + if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler))) + { + return false; + } + } + } + + return sax->end_array(); + } + + /*! + @param[in] len the length of the object or static_cast(-1) for an + object of indefinite size + @param[in] tag_handler how CBOR tags should be treated + @return whether object creation completed + */ + bool get_cbor_object(const std::size_t len, + const cbor_tag_handler_t tag_handler) + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len))) + { + return false; + } + + if (len != 0) + { + string_t key; + if (len != static_cast(-1)) + { + for (std::size_t i = 0; i < len; ++i) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key))) + { + return false; + } + + if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) + { + return false; + } + key.clear(); + } + } + else + { + while (get() != 0xFF) + { + if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key))) + { + return false; + } + + if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) + { + return false; + } + key.clear(); + } + } + } + + return sax->end_object(); + } + + ///////////// + // MsgPack // + ///////////// + + /*! + @return whether a valid MessagePack value was passed to the SAX parser + */ + bool parse_msgpack_internal() + { + switch (get()) + { + // EOF + case char_traits::eof(): + return unexpect_eof(input_format_t::msgpack, "value"); + + // positive fixint + case 0x00: + case 0x01: + case 0x02: + case 0x03: + case 0x04: + case 0x05: + case 0x06: + case 0x07: + case 0x08: + case 0x09: + case 0x0A: + case 0x0B: + case 0x0C: + case 0x0D: + case 0x0E: + case 0x0F: + case 0x10: + case 0x11: + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + case 0x28: + case 0x29: + case 0x2A: + case 0x2B: + case 0x2C: + case 0x2D: + case 0x2E: + case 0x2F: + case 0x30: + case 0x31: + case 0x32: + case 0x33: + case 0x34: + case 0x35: + case 0x36: + case 0x37: + case 0x38: + case 0x39: + case 0x3A: + case 0x3B: + case 0x3C: + case 0x3D: + case 0x3E: + case 0x3F: + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4A: + case 0x4B: + case 0x4C: + case 0x4D: + case 0x4E: + case 0x4F: + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + case 0x58: + case 0x59: + case 0x5A: + case 0x5B: + case 0x5C: + case 0x5D: + case 0x5E: + case 0x5F: + case 0x60: + case 0x61: + case 0x62: + case 0x63: + case 0x64: + case 0x65: + case 0x66: + case 0x67: + case 0x68: + case 0x69: + case 0x6A: + case 0x6B: + case 0x6C: + case 0x6D: + case 0x6E: + case 0x6F: + case 0x70: + case 0x71: + case 0x72: + case 0x73: + case 0x74: + case 0x75: + case 0x76: + case 0x77: + case 0x78: + case 0x79: + case 0x7A: + case 0x7B: + case 0x7C: + case 0x7D: + case 0x7E: + case 0x7F: + return sax->number_unsigned(static_cast(current)); + + // fixmap + case 0x80: + case 0x81: + case 0x82: + case 0x83: + case 0x84: + case 0x85: + case 0x86: + case 0x87: + case 0x88: + case 0x89: + case 0x8A: + case 0x8B: + case 0x8C: + case 0x8D: + case 0x8E: + case 0x8F: + return get_msgpack_object(conditional_static_cast(static_cast(current) & 0x0Fu)); + + // fixarray + case 0x90: + case 0x91: + case 0x92: + case 0x93: + case 0x94: + case 0x95: + case 0x96: + case 0x97: + case 0x98: + case 0x99: + case 0x9A: + case 0x9B: + case 0x9C: + case 0x9D: + case 0x9E: + case 0x9F: + return get_msgpack_array(conditional_static_cast(static_cast(current) & 0x0Fu)); + + // fixstr + case 0xA0: + case 0xA1: + case 0xA2: + case 0xA3: + case 0xA4: + case 0xA5: + case 0xA6: + case 0xA7: + case 0xA8: + case 0xA9: + case 0xAA: + case 0xAB: + case 0xAC: + case 0xAD: + case 0xAE: + case 0xAF: + case 0xB0: + case 0xB1: + case 0xB2: + case 0xB3: + case 0xB4: + case 0xB5: + case 0xB6: + case 0xB7: + case 0xB8: + case 0xB9: + case 0xBA: + case 0xBB: + case 0xBC: + case 0xBD: + case 0xBE: + case 0xBF: + case 0xD9: // str 8 + case 0xDA: // str 16 + case 0xDB: // str 32 + { + string_t s; + return get_msgpack_string(s) && sax->string(s); + } + + case 0xC0: // nil + return sax->null(); + + case 0xC2: // false + return sax->boolean(false); + + case 0xC3: // true + return sax->boolean(true); + + case 0xC4: // bin 8 + case 0xC5: // bin 16 + case 0xC6: // bin 32 + case 0xC7: // ext 8 + case 0xC8: // ext 16 + case 0xC9: // ext 32 + case 0xD4: // fixext 1 + case 0xD5: // fixext 2 + case 0xD6: // fixext 4 + case 0xD7: // fixext 8 + case 0xD8: // fixext 16 + { + binary_t b; + return get_msgpack_binary(b) && sax->binary(b); + } + + case 0xCA: // float 32 + { + float number{}; + return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast(number), ""); + } + + case 0xCB: // float 64 + { + double number{}; + return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast(number), ""); + } + + case 0xCC: // uint 8 + { + std::uint8_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); + } + + case 0xCD: // uint 16 + { + std::uint16_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); + } + + case 0xCE: // uint 32 + { + std::uint32_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); + } + + case 0xCF: // uint 64 + { + std::uint64_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); + } + + case 0xD0: // int 8 + { + std::int8_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_integer(number); + } + + case 0xD1: // int 16 + { + std::int16_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_integer(number); + } + + case 0xD2: // int 32 + { + std::int32_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_integer(number); + } + + case 0xD3: // int 64 + { + std::int64_t number{}; + return get_number(input_format_t::msgpack, number) && sax->number_integer(number); + } + + case 0xDC: // array 16 + { + std::uint16_t len{}; + return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast(len)); + } + + case 0xDD: // array 32 + { + std::uint32_t len{}; + return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast(len)); + } + + case 0xDE: // map 16 + { + std::uint16_t len{}; + return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast(len)); + } + + case 0xDF: // map 32 + { + std::uint32_t len{}; + return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast(len)); + } + + // negative fixint + case 0xE0: + case 0xE1: + case 0xE2: + case 0xE3: + case 0xE4: + case 0xE5: + case 0xE6: + case 0xE7: + case 0xE8: + case 0xE9: + case 0xEA: + case 0xEB: + case 0xEC: + case 0xED: + case 0xEE: + case 0xEF: + case 0xF0: + case 0xF1: + case 0xF2: + case 0xF3: + case 0xF4: + case 0xF5: + case 0xF6: + case 0xF7: + case 0xF8: + case 0xF9: + case 0xFA: + case 0xFB: + case 0xFC: + case 0xFD: + case 0xFE: + case 0xFF: + return sax->number_integer(static_cast(current)); + + default: // anything else + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr)); + } + } + } + + /*! + @brief reads a MessagePack string + + This function first reads starting bytes to determine the expected + string length and then copies this number of bytes into a string. + + @param[out] result created string + + @return whether string creation completed + */ + bool get_msgpack_string(string_t& result) + { + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string"))) + { + return false; + } + + switch (current) + { + // fixstr + case 0xA0: + case 0xA1: + case 0xA2: + case 0xA3: + case 0xA4: + case 0xA5: + case 0xA6: + case 0xA7: + case 0xA8: + case 0xA9: + case 0xAA: + case 0xAB: + case 0xAC: + case 0xAD: + case 0xAE: + case 0xAF: + case 0xB0: + case 0xB1: + case 0xB2: + case 0xB3: + case 0xB4: + case 0xB5: + case 0xB6: + case 0xB7: + case 0xB8: + case 0xB9: + case 0xBA: + case 0xBB: + case 0xBC: + case 0xBD: + case 0xBE: + case 0xBF: + { + return get_string(input_format_t::msgpack, static_cast(current) & 0x1Fu, result); + } + + case 0xD9: // str 8 + { + std::uint8_t len{}; + return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + } + + case 0xDA: // str 16 + { + std::uint16_t len{}; + return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + } + + case 0xDB: // str 32 + { + std::uint32_t len{}; + return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + } + + default: + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, + exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr)); + } + } + } + + /*! + @brief reads a MessagePack byte array + + This function first reads starting bytes to determine the expected + byte array length and then copies this number of bytes into a byte array. + + @param[out] result created byte array + + @return whether byte array creation completed + */ + bool get_msgpack_binary(binary_t& result) + { + // helper function to set the subtype + auto assign_and_return_true = [&result](std::int8_t subtype) + { + result.set_subtype(static_cast(subtype)); + return true; + }; + + switch (current) + { + case 0xC4: // bin 8 + { + std::uint8_t len{}; + return get_number(input_format_t::msgpack, len) && + get_binary(input_format_t::msgpack, len, result); + } + + case 0xC5: // bin 16 + { + std::uint16_t len{}; + return get_number(input_format_t::msgpack, len) && + get_binary(input_format_t::msgpack, len, result); + } + + case 0xC6: // bin 32 + { + std::uint32_t len{}; + return get_number(input_format_t::msgpack, len) && + get_binary(input_format_t::msgpack, len, result); + } + + case 0xC7: // ext 8 + { + std::uint8_t len{}; + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, len) && + get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, len, result) && + assign_and_return_true(subtype); + } + + case 0xC8: // ext 16 + { + std::uint16_t len{}; + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, len) && + get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, len, result) && + assign_and_return_true(subtype); + } + + case 0xC9: // ext 32 + { + std::uint32_t len{}; + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, len) && + get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, len, result) && + assign_and_return_true(subtype); + } + + case 0xD4: // fixext 1 + { + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, 1, result) && + assign_and_return_true(subtype); + } + + case 0xD5: // fixext 2 + { + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, 2, result) && + assign_and_return_true(subtype); + } + + case 0xD6: // fixext 4 + { + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, 4, result) && + assign_and_return_true(subtype); + } + + case 0xD7: // fixext 8 + { + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, 8, result) && + assign_and_return_true(subtype); + } + + case 0xD8: // fixext 16 + { + std::int8_t subtype{}; + return get_number(input_format_t::msgpack, subtype) && + get_binary(input_format_t::msgpack, 16, result) && + assign_and_return_true(subtype); + } + + default: // LCOV_EXCL_LINE + return false; // LCOV_EXCL_LINE + } + } + + /*! + @param[in] len the length of the array + @return whether array creation completed + */ + bool get_msgpack_array(const std::size_t len) + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len))) + { + return false; + } + + for (std::size_t i = 0; i < len; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal())) + { + return false; + } + } + + return sax->end_array(); + } + + /*! + @param[in] len the length of the object + @return whether object creation completed + */ + bool get_msgpack_object(const std::size_t len) + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len))) + { + return false; + } + + string_t key; + for (std::size_t i = 0; i < len; ++i) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key))) + { + return false; + } + + if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal())) + { + return false; + } + key.clear(); + } + + return sax->end_object(); + } + + //////////// + // UBJSON // + //////////// + + /*! + @param[in] get_char whether a new character should be retrieved from the + input (true, default) or whether the last read + character should be considered instead + + @return whether a valid UBJSON value was passed to the SAX parser + */ + bool parse_ubjson_internal(const bool get_char = true) + { + return get_ubjson_value(get_char ? get_ignore_noop() : current); + } + + /*! + @brief reads a UBJSON string + + This function is either called after reading the 'S' byte explicitly + indicating a string, or in case of an object key where the 'S' byte can be + left out. + + @param[out] result created string + @param[in] get_char whether a new character should be retrieved from the + input (true, default) or whether the last read + character should be considered instead + + @return whether string creation completed + */ + bool get_ubjson_string(string_t& result, const bool get_char = true) + { + if (get_char) + { + get(); // TODO(niels): may we ignore N here? + } + + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) + { + return false; + } + + switch (current) + { + case 'U': + { + std::uint8_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'i': + { + std::int8_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'I': + { + std::int16_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'l': + { + std::int32_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'L': + { + std::int64_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'u': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint16_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'm': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint32_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + case 'M': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint64_t len{}; + return get_number(input_format, len) && get_string(input_format, len, result); + } + + default: + break; + } + auto last_token = get_token_string(); + std::string message; + + if (input_format != input_format_t::bjdata) + { + message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token; + } + else + { + message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token; + } + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr)); + } + + /*! + @param[out] dim an integer vector storing the ND array dimensions + @return whether reading ND array size vector is successful + */ + bool get_ubjson_ndarray_size(std::vector& dim) + { + std::pair size_and_type; + size_t dimlen = 0; + bool no_ndarray = true; + + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray))) + { + return false; + } + + if (size_and_type.first != npos) + { + if (size_and_type.second != 0) + { + if (size_and_type.second != 'N') + { + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second))) + { + return false; + } + dim.push_back(dimlen); + } + } + } + else + { + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray))) + { + return false; + } + dim.push_back(dimlen); + } + } + } + else + { + while (current != ']') + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current))) + { + return false; + } + dim.push_back(dimlen); + get_ignore_noop(); + } + } + return true; + } + + /*! + @param[out] result determined size + @param[in,out] is_ndarray for input, `true` means already inside an ndarray vector + or ndarray dimension is not allowed; `false` means ndarray + is allowed; for output, `true` means an ndarray is found; + is_ndarray can only return `true` when its initial value + is `false` + @param[in] prefix type marker if already read, otherwise set to 0 + + @return whether size determination completed + */ + bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0) + { + if (prefix == 0) + { + prefix = get_ignore_noop(); + } + + switch (prefix) + { + case 'U': + { + std::uint8_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + result = static_cast(number); + return true; + } + + case 'i': + { + std::int8_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + if (number < 0) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, + exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + } + result = static_cast(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char + return true; + } + + case 'I': + { + std::int16_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + if (number < 0) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, + exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + } + result = static_cast(number); + return true; + } + + case 'l': + { + std::int32_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + if (number < 0) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, + exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + } + result = static_cast(number); + return true; + } + + case 'L': + { + std::int64_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + if (number < 0) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, + exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + } + if (!value_in_range_of(number)) + { + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, + exception_message(input_format, "integer value overflow", "size"), nullptr)); + } + result = static_cast(number); + return true; + } + + case 'u': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint16_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + result = static_cast(number); + return true; + } + + case 'm': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint32_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + result = conditional_static_cast(number); + return true; + } + + case 'M': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint64_t number{}; + if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + { + return false; + } + if (!value_in_range_of(number)) + { + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, + exception_message(input_format, "integer value overflow", "size"), nullptr)); + } + result = detail::conditional_static_cast(number); + return true; + } + + case '[': + { + if (input_format != input_format_t::bjdata) + { + break; + } + if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr)); + } + std::vector dim; + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim))) + { + return false; + } + if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector + { + result = dim.at(dim.size() - 1); + return true; + } + if (!dim.empty()) // if ndarray, convert to an object in JData annotated array format + { + for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container + { + if ( i == 0 ) + { + result = 0; + return true; + } + } + + string_t key = "_ArraySize_"; + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size()))) + { + return false; + } + result = 1; + for (auto i : dim) + { + result *= i; + if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type() + { + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr)); + } + if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast(i)))) + { + return false; + } + } + is_ndarray = true; + return sax->end_array(); + } + result = 0; + return true; + } + + default: + break; + } + auto last_token = get_token_string(); + std::string message; + + if (input_format != input_format_t::bjdata) + { + message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token; + } + else + { + message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token; + } + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr)); + } + + /*! + @brief determine the type and size for a container + + In the optimized UBJSON format, a type and a size can be provided to allow + for a more compact representation. + + @param[out] result pair of the size and the type + @param[in] inside_ndarray whether the parser is parsing an ND array dimensional vector + + @return whether pair creation completed + */ + bool get_ubjson_size_type(std::pair& result, bool inside_ndarray = false) + { + result.first = npos; // size + result.second = 0; // type + bool is_ndarray = false; + + get_ignore_noop(); + + if (current == '$') + { + result.second = get(); // must not ignore 'N', because 'N' maybe the type + if (input_format == input_format_t::bjdata + && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second))) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr)); + } + + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type"))) + { + return false; + } + + get_ignore_noop(); + if (JSON_HEDLEY_UNLIKELY(current != '#')) + { + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) + { + return false; + } + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr)); + } + + const bool is_error = get_ubjson_size_value(result.first, is_ndarray); + if (input_format == input_format_t::bjdata && is_ndarray) + { + if (inside_ndarray) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, + exception_message(input_format, "ndarray can not be recursive", "size"), nullptr)); + } + result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters + } + return is_error; + } + + if (current == '#') + { + const bool is_error = get_ubjson_size_value(result.first, is_ndarray); + if (input_format == input_format_t::bjdata && is_ndarray) + { + return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, + exception_message(input_format, "ndarray requires both type and size", "size"), nullptr)); + } + return is_error; + } + + return true; + } + + /*! + @param prefix the previously read or set type prefix + @return whether value creation completed + */ + bool get_ubjson_value(const char_int_type prefix) + { + switch (prefix) + { + case char_traits::eof(): // EOF + return unexpect_eof(input_format, "value"); + + case 'T': // true + return sax->boolean(true); + case 'F': // false + return sax->boolean(false); + + case 'Z': // null + return sax->null(); + + case 'U': + { + std::uint8_t number{}; + return get_number(input_format, number) && sax->number_unsigned(number); + } + + case 'i': + { + std::int8_t number{}; + return get_number(input_format, number) && sax->number_integer(number); + } + + case 'I': + { + std::int16_t number{}; + return get_number(input_format, number) && sax->number_integer(number); + } + + case 'l': + { + std::int32_t number{}; + return get_number(input_format, number) && sax->number_integer(number); + } + + case 'L': + { + std::int64_t number{}; + return get_number(input_format, number) && sax->number_integer(number); + } + + case 'u': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint16_t number{}; + return get_number(input_format, number) && sax->number_unsigned(number); + } + + case 'm': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint32_t number{}; + return get_number(input_format, number) && sax->number_unsigned(number); + } + + case 'M': + { + if (input_format != input_format_t::bjdata) + { + break; + } + std::uint64_t number{}; + return get_number(input_format, number) && sax->number_unsigned(number); + } + + case 'h': + { + if (input_format != input_format_t::bjdata) + { + break; + } + const auto byte1_raw = get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + { + return false; + } + const auto byte2_raw = get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + { + return false; + } + + const auto byte1 = static_cast(byte1_raw); + const auto byte2 = static_cast(byte2_raw); + + // code from RFC 7049, Appendix D, Figure 3: + // As half-precision floating-point numbers were only added + // to IEEE 754 in 2008, today's programming platforms often + // still only have limited support for them. It is very + // easy to include at least decoding support for them even + // without such support. An example of a small decoder for + // half-precision floating-point numbers in the C language + // is shown in Fig. 3. + const auto half = static_cast((byte2 << 8u) + byte1); + const double val = [&half] + { + const int exp = (half >> 10u) & 0x1Fu; + const unsigned int mant = half & 0x3FFu; + JSON_ASSERT(0 <= exp&& exp <= 32); + JSON_ASSERT(mant <= 1024); + switch (exp) + { + case 0: + return std::ldexp(mant, -24); + case 31: + return (mant == 0) + ? std::numeric_limits::infinity() + : std::numeric_limits::quiet_NaN(); + default: + return std::ldexp(mant + 1024, exp - 25); + } + }(); + return sax->number_float((half & 0x8000u) != 0 + ? static_cast(-val) + : static_cast(val), ""); + } + + case 'd': + { + float number{}; + return get_number(input_format, number) && sax->number_float(static_cast(number), ""); + } + + case 'D': + { + double number{}; + return get_number(input_format, number) && sax->number_float(static_cast(number), ""); + } + + case 'H': + { + return get_ubjson_high_precision_number(); + } + + case 'C': // char + { + get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char"))) + { + return false; + } + if (JSON_HEDLEY_UNLIKELY(current > 127)) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, + exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr)); + } + string_t s(1, static_cast(current)); + return sax->string(s); + } + + case 'S': // string + { + string_t s; + return get_ubjson_string(s) && sax->string(s); + } + + case '[': // array + return get_ubjson_array(); + + case '{': // object + return get_ubjson_object(); + + default: // anything else + break; + } + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr)); + } + + /*! + @return whether array creation completed + */ + bool get_ubjson_array() + { + std::pair size_and_type; + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type))) + { + return false; + } + + // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata): + // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]} + + if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0) + { + size_and_type.second &= ~(static_cast(1) << 8); // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker + auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t) + { + return p.first < t; + }); + string_t key = "_ArrayType_"; + if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second)) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr)); + } + + string_t type = it->second; // sax->string() takes a reference + if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type))) + { + return false; + } + + if (size_and_type.second == 'C') + { + size_and_type.second = 'U'; + } + + key = "_ArrayData_"; + if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) )) + { + return false; + } + + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) + { + return false; + } + } + + return (sax->end_array() && sax->end_object()); + } + + if (size_and_type.first != npos) + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first))) + { + return false; + } + + if (size_and_type.second != 0) + { + if (size_and_type.second != 'N') + { + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) + { + return false; + } + } + } + } + else + { + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) + { + return false; + } + } + } + } + else + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast(-1)))) + { + return false; + } + + while (current != ']') + { + if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false))) + { + return false; + } + get_ignore_noop(); + } + } + + return sax->end_array(); + } + + /*! + @return whether object creation completed + */ + bool get_ubjson_object() + { + std::pair size_and_type; + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type))) + { + return false; + } + + // do not accept ND-array size in objects in BJData + if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0) + { + auto last_token = get_token_string(); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, + exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr)); + } + + string_t key; + if (size_and_type.first != npos) + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first))) + { + return false; + } + + if (size_and_type.second != 0) + { + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key))) + { + return false; + } + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) + { + return false; + } + key.clear(); + } + } + else + { + for (std::size_t i = 0; i < size_and_type.first; ++i) + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key))) + { + return false; + } + if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) + { + return false; + } + key.clear(); + } + } + } + else + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast(-1)))) + { + return false; + } + + while (current != '}') + { + if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key))) + { + return false; + } + if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) + { + return false; + } + get_ignore_noop(); + key.clear(); + } + } + + return sax->end_object(); + } + + // Note, no reader for UBJSON binary types is implemented because they do + // not exist + + bool get_ubjson_high_precision_number() + { + // get size of following number string + std::size_t size{}; + bool no_ndarray = true; + auto res = get_ubjson_size_value(size, no_ndarray); + if (JSON_HEDLEY_UNLIKELY(!res)) + { + return res; + } + + // get number string + std::vector number_vector; + for (std::size_t i = 0; i < size; ++i) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + { + return false; + } + number_vector.push_back(static_cast(current)); + } + + // parse number string + using ia_type = decltype(detail::input_adapter(number_vector)); + auto number_lexer = detail::lexer(detail::input_adapter(number_vector), false); + const auto result_number = number_lexer.scan(); + const auto number_string = number_lexer.get_token_string(); + const auto result_remainder = number_lexer.scan(); + + using token_type = typename detail::lexer_base::token_type; + + if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input)) + { + return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, + exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); + } + + switch (result_number) + { + case token_type::value_integer: + return sax->number_integer(number_lexer.get_number_integer()); + case token_type::value_unsigned: + return sax->number_unsigned(number_lexer.get_number_unsigned()); + case token_type::value_float: + return sax->number_float(number_lexer.get_number_float(), std::move(number_string)); + case token_type::uninitialized: + case token_type::literal_true: + case token_type::literal_false: + case token_type::literal_null: + case token_type::value_string: + case token_type::begin_array: + case token_type::begin_object: + case token_type::end_array: + case token_type::end_object: + case token_type::name_separator: + case token_type::value_separator: + case token_type::parse_error: + case token_type::end_of_input: + case token_type::literal_or_value: + default: + return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, + exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); + } + } + + /////////////////////// + // Utility functions // + /////////////////////// + + /*! + @brief get next character from the input + + This function provides the interface to the used input adapter. It does + not throw in case the input reached EOF, but returns a -'ve valued + `char_traits::eof()` in that case. + + @return character read from the input + */ + char_int_type get() + { + ++chars_read; + return current = ia.get_character(); + } + + /*! + @return character read from the input after ignoring all 'N' entries + */ + char_int_type get_ignore_noop() + { + do + { + get(); + } + while (current == 'N'); + + return current; + } + + /* + @brief read a number from the input + + @tparam NumberType the type of the number + @param[in] format the current format (for diagnostics) + @param[out] result number of type @a NumberType + + @return whether conversion completed + + @note This function needs to respect the system's endianness, because + bytes in CBOR, MessagePack, and UBJSON are stored in network order + (big endian) and therefore need reordering on little endian systems. + On the other hand, BSON and BJData use little endian and should reorder + on big endian systems. + */ + template + bool get_number(const input_format_t format, NumberType& result) + { + // step 1: read input into array with system's byte order + std::array vec{}; + for (std::size_t i = 0; i < sizeof(NumberType); ++i) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number"))) + { + return false; + } + + // reverse byte order prior to conversion if necessary + if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata)) + { + vec[sizeof(NumberType) - i - 1] = static_cast(current); + } + else + { + vec[i] = static_cast(current); // LCOV_EXCL_LINE + } + } + + // step 2: convert array into number of type T and return + std::memcpy(&result, vec.data(), sizeof(NumberType)); + return true; + } + + /*! + @brief create a string by reading characters from the input + + @tparam NumberType the type of the number + @param[in] format the current format (for diagnostics) + @param[in] len number of characters to read + @param[out] result string created by reading @a len bytes + + @return whether string creation completed + + @note We can not reserve @a len bytes for the result, because @a len + may be too large. Usually, @ref unexpect_eof() detects the end of + the input before we run out of string memory. + */ + template + bool get_string(const input_format_t format, + const NumberType len, + string_t& result) + { + bool success = true; + for (NumberType i = 0; i < len; i++) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string"))) + { + success = false; + break; + } + result.push_back(static_cast(current)); + } + return success; + } + + /*! + @brief create a byte array by reading bytes from the input + + @tparam NumberType the type of the number + @param[in] format the current format (for diagnostics) + @param[in] len number of bytes to read + @param[out] result byte array created by reading @a len bytes + + @return whether byte array creation completed + + @note We can not reserve @a len bytes for the result, because @a len + may be too large. Usually, @ref unexpect_eof() detects the end of + the input before we run out of memory. + */ + template + bool get_binary(const input_format_t format, + const NumberType len, + binary_t& result) + { + bool success = true; + for (NumberType i = 0; i < len; i++) + { + get(); + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary"))) + { + success = false; + break; + } + result.push_back(static_cast(current)); + } + return success; + } + + /*! + @param[in] format the current format (for diagnostics) + @param[in] context further context information (for diagnostics) + @return whether the last read character is not EOF + */ + JSON_HEDLEY_NON_NULL(3) + bool unexpect_eof(const input_format_t format, const char* context) const + { + if (JSON_HEDLEY_UNLIKELY(current == char_traits::eof())) + { + return sax->parse_error(chars_read, "", + parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr)); + } + return true; + } + + /*! + @return a string representation of the last read byte + */ + std::string get_token_string() const + { + std::array cr{{}}; + static_cast((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) + return std::string{cr.data()}; + } + + /*! + @param[in] format the current format + @param[in] detail a detailed error message + @param[in] context further context information + @return a message string to use in the parse_error exceptions + */ + std::string exception_message(const input_format_t format, + const std::string& detail, + const std::string& context) const + { + std::string error_msg = "syntax error while parsing "; + + switch (format) + { + case input_format_t::cbor: + error_msg += "CBOR"; + break; + + case input_format_t::msgpack: + error_msg += "MessagePack"; + break; + + case input_format_t::ubjson: + error_msg += "UBJSON"; + break; + + case input_format_t::bson: + error_msg += "BSON"; + break; + + case input_format_t::bjdata: + error_msg += "BJData"; + break; + + case input_format_t::json: // LCOV_EXCL_LINE + default: // LCOV_EXCL_LINE + JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE + } + + return concat(error_msg, ' ', context, ": ", detail); + } + + private: + static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast(-1); + + /// input adapter + InputAdapterType ia; + + /// the current character + char_int_type current = char_traits::eof(); + + /// the number of characters read + std::size_t chars_read = 0; + + /// whether we can assume little endianness + const bool is_little_endian = little_endianness(); + + /// input format + const input_format_t input_format = input_format_t::json; + + /// the SAX parser + json_sax_t* sax = nullptr; + + // excluded markers in bjdata optimized type +#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \ + make_array('F', 'H', 'N', 'S', 'T', 'Z', '[', '{') + +#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \ + make_array( \ + bjd_type{'C', "char"}, \ + bjd_type{'D', "double"}, \ + bjd_type{'I', "int16"}, \ + bjd_type{'L', "int64"}, \ + bjd_type{'M', "uint64"}, \ + bjd_type{'U', "uint8"}, \ + bjd_type{'d', "single"}, \ + bjd_type{'i', "int8"}, \ + bjd_type{'l', "int32"}, \ + bjd_type{'m', "uint32"}, \ + bjd_type{'u', "uint16"}) + + JSON_PRIVATE_UNLESS_TESTED: + // lookup tables + // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes) + const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers = + JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_; + + using bjd_type = std::pair; + // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes) + const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map = + JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_; + +#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ +#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr std::size_t binary_reader::npos; +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/input_adapters.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/input_adapters.hpp new file mode 100644 index 0000000..33fca3e --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/input_adapters.hpp @@ -0,0 +1,492 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // array +#include // size_t +#include // strlen +#include // begin, end, iterator_traits, random_access_iterator_tag, distance, next +#include // shared_ptr, make_shared, addressof +#include // accumulate +#include // string, char_traits +#include // enable_if, is_base_of, is_pointer, is_integral, remove_pointer +#include // pair, declval + +#ifndef JSON_NO_IO + #include // FILE * + #include // istream +#endif // JSON_NO_IO + +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// the supported input formats +enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata }; + +//////////////////// +// input adapters // +//////////////////// + +#ifndef JSON_NO_IO +/*! +Input adapter for stdio file access. This adapter read only 1 byte and do not use any + buffer. This adapter is a very low level adapter. +*/ +class file_input_adapter +{ + public: + using char_type = char; + + JSON_HEDLEY_NON_NULL(2) + explicit file_input_adapter(std::FILE* f) noexcept + : m_file(f) + { + JSON_ASSERT(m_file != nullptr); + } + + // make class move-only + file_input_adapter(const file_input_adapter&) = delete; + file_input_adapter(file_input_adapter&&) noexcept = default; + file_input_adapter& operator=(const file_input_adapter&) = delete; + file_input_adapter& operator=(file_input_adapter&&) = delete; + ~file_input_adapter() = default; + + std::char_traits::int_type get_character() noexcept + { + return std::fgetc(m_file); + } + + private: + /// the file pointer to read from + std::FILE* m_file; +}; + +/*! +Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at +beginning of input. Does not support changing the underlying std::streambuf +in mid-input. Maintains underlying std::istream and std::streambuf to support +subsequent use of standard std::istream operations to process any input +characters following those used in parsing the JSON input. Clears the +std::istream flags; any input errors (e.g., EOF) will be detected by the first +subsequent call for input from the std::istream. +*/ +class input_stream_adapter +{ + public: + using char_type = char; + + ~input_stream_adapter() + { + // clear stream flags; we use underlying streambuf I/O, do not + // maintain ifstream flags, except eof + if (is != nullptr) + { + is->clear(is->rdstate() & std::ios::eofbit); + } + } + + explicit input_stream_adapter(std::istream& i) + : is(&i), sb(i.rdbuf()) + {} + + // delete because of pointer members + input_stream_adapter(const input_stream_adapter&) = delete; + input_stream_adapter& operator=(input_stream_adapter&) = delete; + input_stream_adapter& operator=(input_stream_adapter&&) = delete; + + input_stream_adapter(input_stream_adapter&& rhs) noexcept + : is(rhs.is), sb(rhs.sb) + { + rhs.is = nullptr; + rhs.sb = nullptr; + } + + // std::istream/std::streambuf use std::char_traits::to_int_type, to + // ensure that std::char_traits::eof() and the character 0xFF do not + // end up as the same value, e.g. 0xFFFFFFFF. + std::char_traits::int_type get_character() + { + auto res = sb->sbumpc(); + // set eof manually, as we don't use the istream interface. + if (JSON_HEDLEY_UNLIKELY(res == std::char_traits::eof())) + { + is->clear(is->rdstate() | std::ios::eofbit); + } + return res; + } + + private: + /// the associated input stream + std::istream* is = nullptr; + std::streambuf* sb = nullptr; +}; +#endif // JSON_NO_IO + +// General-purpose iterator-based adapter. It might not be as fast as +// theoretically possible for some containers, but it is extremely versatile. +template +class iterator_input_adapter +{ + public: + using char_type = typename std::iterator_traits::value_type; + + iterator_input_adapter(IteratorType first, IteratorType last) + : current(std::move(first)), end(std::move(last)) + {} + + typename char_traits::int_type get_character() + { + if (JSON_HEDLEY_LIKELY(current != end)) + { + auto result = char_traits::to_int_type(*current); + std::advance(current, 1); + return result; + } + + return char_traits::eof(); + } + + private: + IteratorType current; + IteratorType end; + + template + friend struct wide_string_input_helper; + + bool empty() const + { + return current == end; + } +}; + +template +struct wide_string_input_helper; + +template +struct wide_string_input_helper +{ + // UTF-32 + static void fill_buffer(BaseInputAdapter& input, + std::array::int_type, 4>& utf8_bytes, + size_t& utf8_bytes_index, + size_t& utf8_bytes_filled) + { + utf8_bytes_index = 0; + + if (JSON_HEDLEY_UNLIKELY(input.empty())) + { + utf8_bytes[0] = std::char_traits::eof(); + utf8_bytes_filled = 1; + } + else + { + // get the current character + const auto wc = input.get_character(); + + // UTF-32 to UTF-8 encoding + if (wc < 0x80) + { + utf8_bytes[0] = static_cast::int_type>(wc); + utf8_bytes_filled = 1; + } + else if (wc <= 0x7FF) + { + utf8_bytes[0] = static_cast::int_type>(0xC0u | ((static_cast(wc) >> 6u) & 0x1Fu)); + utf8_bytes[1] = static_cast::int_type>(0x80u | (static_cast(wc) & 0x3Fu)); + utf8_bytes_filled = 2; + } + else if (wc <= 0xFFFF) + { + utf8_bytes[0] = static_cast::int_type>(0xE0u | ((static_cast(wc) >> 12u) & 0x0Fu)); + utf8_bytes[1] = static_cast::int_type>(0x80u | ((static_cast(wc) >> 6u) & 0x3Fu)); + utf8_bytes[2] = static_cast::int_type>(0x80u | (static_cast(wc) & 0x3Fu)); + utf8_bytes_filled = 3; + } + else if (wc <= 0x10FFFF) + { + utf8_bytes[0] = static_cast::int_type>(0xF0u | ((static_cast(wc) >> 18u) & 0x07u)); + utf8_bytes[1] = static_cast::int_type>(0x80u | ((static_cast(wc) >> 12u) & 0x3Fu)); + utf8_bytes[2] = static_cast::int_type>(0x80u | ((static_cast(wc) >> 6u) & 0x3Fu)); + utf8_bytes[3] = static_cast::int_type>(0x80u | (static_cast(wc) & 0x3Fu)); + utf8_bytes_filled = 4; + } + else + { + // unknown character + utf8_bytes[0] = static_cast::int_type>(wc); + utf8_bytes_filled = 1; + } + } + } +}; + +template +struct wide_string_input_helper +{ + // UTF-16 + static void fill_buffer(BaseInputAdapter& input, + std::array::int_type, 4>& utf8_bytes, + size_t& utf8_bytes_index, + size_t& utf8_bytes_filled) + { + utf8_bytes_index = 0; + + if (JSON_HEDLEY_UNLIKELY(input.empty())) + { + utf8_bytes[0] = std::char_traits::eof(); + utf8_bytes_filled = 1; + } + else + { + // get the current character + const auto wc = input.get_character(); + + // UTF-16 to UTF-8 encoding + if (wc < 0x80) + { + utf8_bytes[0] = static_cast::int_type>(wc); + utf8_bytes_filled = 1; + } + else if (wc <= 0x7FF) + { + utf8_bytes[0] = static_cast::int_type>(0xC0u | ((static_cast(wc) >> 6u))); + utf8_bytes[1] = static_cast::int_type>(0x80u | (static_cast(wc) & 0x3Fu)); + utf8_bytes_filled = 2; + } + else if (0xD800 > wc || wc >= 0xE000) + { + utf8_bytes[0] = static_cast::int_type>(0xE0u | ((static_cast(wc) >> 12u))); + utf8_bytes[1] = static_cast::int_type>(0x80u | ((static_cast(wc) >> 6u) & 0x3Fu)); + utf8_bytes[2] = static_cast::int_type>(0x80u | (static_cast(wc) & 0x3Fu)); + utf8_bytes_filled = 3; + } + else + { + if (JSON_HEDLEY_UNLIKELY(!input.empty())) + { + const auto wc2 = static_cast(input.get_character()); + const auto charcode = 0x10000u + (((static_cast(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu)); + utf8_bytes[0] = static_cast::int_type>(0xF0u | (charcode >> 18u)); + utf8_bytes[1] = static_cast::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu)); + utf8_bytes[2] = static_cast::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu)); + utf8_bytes[3] = static_cast::int_type>(0x80u | (charcode & 0x3Fu)); + utf8_bytes_filled = 4; + } + else + { + utf8_bytes[0] = static_cast::int_type>(wc); + utf8_bytes_filled = 1; + } + } + } + } +}; + +// Wraps another input adapter to convert wide character types into individual bytes. +template +class wide_string_input_adapter +{ + public: + using char_type = char; + + wide_string_input_adapter(BaseInputAdapter base) + : base_adapter(base) {} + + typename std::char_traits::int_type get_character() noexcept + { + // check if buffer needs to be filled + if (utf8_bytes_index == utf8_bytes_filled) + { + fill_buffer(); + + JSON_ASSERT(utf8_bytes_filled > 0); + JSON_ASSERT(utf8_bytes_index == 0); + } + + // use buffer + JSON_ASSERT(utf8_bytes_filled > 0); + JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled); + return utf8_bytes[utf8_bytes_index++]; + } + + private: + BaseInputAdapter base_adapter; + + template + void fill_buffer() + { + wide_string_input_helper::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled); + } + + /// a buffer for UTF-8 bytes + std::array::int_type, 4> utf8_bytes = {{0, 0, 0, 0}}; + + /// index to the utf8_codes array for the next valid byte + std::size_t utf8_bytes_index = 0; + /// number of valid bytes in the utf8_codes array + std::size_t utf8_bytes_filled = 0; +}; + +template +struct iterator_input_adapter_factory +{ + using iterator_type = IteratorType; + using char_type = typename std::iterator_traits::value_type; + using adapter_type = iterator_input_adapter; + + static adapter_type create(IteratorType first, IteratorType last) + { + return adapter_type(std::move(first), std::move(last)); + } +}; + +template +struct is_iterator_of_multibyte +{ + using value_type = typename std::iterator_traits::value_type; + enum + { + value = sizeof(value_type) > 1 + }; +}; + +template +struct iterator_input_adapter_factory::value>> +{ + using iterator_type = IteratorType; + using char_type = typename std::iterator_traits::value_type; + using base_adapter_type = iterator_input_adapter; + using adapter_type = wide_string_input_adapter; + + static adapter_type create(IteratorType first, IteratorType last) + { + return adapter_type(base_adapter_type(std::move(first), std::move(last))); + } +}; + +// General purpose iterator-based input +template +typename iterator_input_adapter_factory::adapter_type input_adapter(IteratorType first, IteratorType last) +{ + using factory_type = iterator_input_adapter_factory; + return factory_type::create(first, last); +} + +// Convenience shorthand from container to iterator +// Enables ADL on begin(container) and end(container) +// Encloses the using declarations in namespace for not to leak them to outside scope + +namespace container_input_adapter_factory_impl +{ + +using std::begin; +using std::end; + +template +struct container_input_adapter_factory {}; + +template +struct container_input_adapter_factory< ContainerType, + void_t()), end(std::declval()))>> + { + using adapter_type = decltype(input_adapter(begin(std::declval()), end(std::declval()))); + + static adapter_type create(const ContainerType& container) +{ + return input_adapter(begin(container), end(container)); +} + }; + +} // namespace container_input_adapter_factory_impl + +template +typename container_input_adapter_factory_impl::container_input_adapter_factory::adapter_type input_adapter(const ContainerType& container) +{ + return container_input_adapter_factory_impl::container_input_adapter_factory::create(container); +} + +#ifndef JSON_NO_IO +// Special cases with fast paths +inline file_input_adapter input_adapter(std::FILE* file) +{ + return file_input_adapter(file); +} + +inline input_stream_adapter input_adapter(std::istream& stream) +{ + return input_stream_adapter(stream); +} + +inline input_stream_adapter input_adapter(std::istream&& stream) +{ + return input_stream_adapter(stream); +} +#endif // JSON_NO_IO + +using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval(), std::declval())); + +// Null-delimited strings, and the like. +template < typename CharT, + typename std::enable_if < + std::is_pointer::value&& + !std::is_array::value&& + std::is_integral::type>::value&& + sizeof(typename std::remove_pointer::type) == 1, + int >::type = 0 > +contiguous_bytes_input_adapter input_adapter(CharT b) +{ + auto length = std::strlen(reinterpret_cast(b)); + const auto* ptr = reinterpret_cast(b); + return input_adapter(ptr, ptr + length); +} + +template +auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) +{ + return input_adapter(array, array + N); +} + +// This class only handles inputs of input_buffer_adapter type. +// It's required so that expressions like {ptr, len} can be implicitly cast +// to the correct adapter. +class span_input_adapter +{ + public: + template < typename CharT, + typename std::enable_if < + std::is_pointer::value&& + std::is_integral::type>::value&& + sizeof(typename std::remove_pointer::type) == 1, + int >::type = 0 > + span_input_adapter(CharT b, std::size_t l) + : ia(reinterpret_cast(b), reinterpret_cast(b) + l) {} + + template::iterator_category, std::random_access_iterator_tag>::value, + int>::type = 0> + span_input_adapter(IteratorType first, IteratorType last) + : ia(input_adapter(first, last)) {} + + contiguous_bytes_input_adapter&& get() + { + return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg) + } + + private: + contiguous_bytes_input_adapter ia; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/json_sax.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/json_sax.hpp new file mode 100644 index 0000000..c772521 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/json_sax.hpp @@ -0,0 +1,727 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include +#include // string +#include // move +#include // vector + +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN + +/*! +@brief SAX interface + +This class describes the SAX interface used by @ref nlohmann::json::sax_parse. +Each function is called in different situations while the input is parsed. The +boolean return value informs the parser whether to continue processing the +input. +*/ +template +struct json_sax +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + + /*! + @brief a null value was read + @return whether parsing should proceed + */ + virtual bool null() = 0; + + /*! + @brief a boolean value was read + @param[in] val boolean value + @return whether parsing should proceed + */ + virtual bool boolean(bool val) = 0; + + /*! + @brief an integer number was read + @param[in] val integer value + @return whether parsing should proceed + */ + virtual bool number_integer(number_integer_t val) = 0; + + /*! + @brief an unsigned integer number was read + @param[in] val unsigned integer value + @return whether parsing should proceed + */ + virtual bool number_unsigned(number_unsigned_t val) = 0; + + /*! + @brief a floating-point number was read + @param[in] val floating-point value + @param[in] s raw token value + @return whether parsing should proceed + */ + virtual bool number_float(number_float_t val, const string_t& s) = 0; + + /*! + @brief a string value was read + @param[in] val string value + @return whether parsing should proceed + @note It is safe to move the passed string value. + */ + virtual bool string(string_t& val) = 0; + + /*! + @brief a binary value was read + @param[in] val binary value + @return whether parsing should proceed + @note It is safe to move the passed binary value. + */ + virtual bool binary(binary_t& val) = 0; + + /*! + @brief the beginning of an object was read + @param[in] elements number of object elements or -1 if unknown + @return whether parsing should proceed + @note binary formats may report the number of elements + */ + virtual bool start_object(std::size_t elements) = 0; + + /*! + @brief an object key was read + @param[in] val object key + @return whether parsing should proceed + @note It is safe to move the passed string. + */ + virtual bool key(string_t& val) = 0; + + /*! + @brief the end of an object was read + @return whether parsing should proceed + */ + virtual bool end_object() = 0; + + /*! + @brief the beginning of an array was read + @param[in] elements number of array elements or -1 if unknown + @return whether parsing should proceed + @note binary formats may report the number of elements + */ + virtual bool start_array(std::size_t elements) = 0; + + /*! + @brief the end of an array was read + @return whether parsing should proceed + */ + virtual bool end_array() = 0; + + /*! + @brief a parse error occurred + @param[in] position the position in the input where the error occurs + @param[in] last_token the last read token + @param[in] ex an exception object describing the error + @return whether parsing should proceed (must return false) + */ + virtual bool parse_error(std::size_t position, + const std::string& last_token, + const detail::exception& ex) = 0; + + json_sax() = default; + json_sax(const json_sax&) = default; + json_sax(json_sax&&) noexcept = default; + json_sax& operator=(const json_sax&) = default; + json_sax& operator=(json_sax&&) noexcept = default; + virtual ~json_sax() = default; +}; + +namespace detail +{ +/*! +@brief SAX implementation to create a JSON value from SAX events + +This class implements the @ref json_sax interface and processes the SAX events +to create a JSON value which makes it basically a DOM parser. The structure or +hierarchy of the JSON value is managed by the stack `ref_stack` which contains +a pointer to the respective array or object for each recursion depth. + +After successful parsing, the value that is passed by reference to the +constructor contains the parsed value. + +@tparam BasicJsonType the JSON type +*/ +template +class json_sax_dom_parser +{ + public: + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + + /*! + @param[in,out] r reference to a JSON value that is manipulated while + parsing + @param[in] allow_exceptions_ whether parse errors yield exceptions + */ + explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true) + : root(r), allow_exceptions(allow_exceptions_) + {} + + // make class move-only + json_sax_dom_parser(const json_sax_dom_parser&) = delete; + json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete; + json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + ~json_sax_dom_parser() = default; + + bool null() + { + handle_value(nullptr); + return true; + } + + bool boolean(bool val) + { + handle_value(val); + return true; + } + + bool number_integer(number_integer_t val) + { + handle_value(val); + return true; + } + + bool number_unsigned(number_unsigned_t val) + { + handle_value(val); + return true; + } + + bool number_float(number_float_t val, const string_t& /*unused*/) + { + handle_value(val); + return true; + } + + bool string(string_t& val) + { + handle_value(val); + return true; + } + + bool binary(binary_t& val) + { + handle_value(std::move(val)); + return true; + } + + bool start_object(std::size_t len) + { + ref_stack.push_back(handle_value(BasicJsonType::value_t::object)); + + if (JSON_HEDLEY_UNLIKELY(len != static_cast(-1) && len > ref_stack.back()->max_size())) + { + JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back())); + } + + return true; + } + + bool key(string_t& val) + { + JSON_ASSERT(!ref_stack.empty()); + JSON_ASSERT(ref_stack.back()->is_object()); + + // add null at given key and store the reference for later + object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val)); + return true; + } + + bool end_object() + { + JSON_ASSERT(!ref_stack.empty()); + JSON_ASSERT(ref_stack.back()->is_object()); + + ref_stack.back()->set_parents(); + ref_stack.pop_back(); + return true; + } + + bool start_array(std::size_t len) + { + ref_stack.push_back(handle_value(BasicJsonType::value_t::array)); + + if (JSON_HEDLEY_UNLIKELY(len != static_cast(-1) && len > ref_stack.back()->max_size())) + { + JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back())); + } + + return true; + } + + bool end_array() + { + JSON_ASSERT(!ref_stack.empty()); + JSON_ASSERT(ref_stack.back()->is_array()); + + ref_stack.back()->set_parents(); + ref_stack.pop_back(); + return true; + } + + template + bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, + const Exception& ex) + { + errored = true; + static_cast(ex); + if (allow_exceptions) + { + JSON_THROW(ex); + } + return false; + } + + constexpr bool is_errored() const + { + return errored; + } + + private: + /*! + @invariant If the ref stack is empty, then the passed value will be the new + root. + @invariant If the ref stack contains a value, then it is an array or an + object to which we can add elements + */ + template + JSON_HEDLEY_RETURNS_NON_NULL + BasicJsonType* handle_value(Value&& v) + { + if (ref_stack.empty()) + { + root = BasicJsonType(std::forward(v)); + return &root; + } + + JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); + + if (ref_stack.back()->is_array()) + { + ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); + return &(ref_stack.back()->m_data.m_value.array->back()); + } + + JSON_ASSERT(ref_stack.back()->is_object()); + JSON_ASSERT(object_element); + *object_element = BasicJsonType(std::forward(v)); + return object_element; + } + + /// the parsed JSON value + BasicJsonType& root; + /// stack to model hierarchy of values + std::vector ref_stack {}; + /// helper to hold the reference for the next object element + BasicJsonType* object_element = nullptr; + /// whether a syntax error occurred + bool errored = false; + /// whether to throw exceptions in case of errors + const bool allow_exceptions = true; +}; + +template +class json_sax_dom_callback_parser +{ + public: + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + using parser_callback_t = typename BasicJsonType::parser_callback_t; + using parse_event_t = typename BasicJsonType::parse_event_t; + + json_sax_dom_callback_parser(BasicJsonType& r, + const parser_callback_t cb, + const bool allow_exceptions_ = true) + : root(r), callback(cb), allow_exceptions(allow_exceptions_) + { + keep_stack.push_back(true); + } + + // make class move-only + json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete; + json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete; + json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + ~json_sax_dom_callback_parser() = default; + + bool null() + { + handle_value(nullptr); + return true; + } + + bool boolean(bool val) + { + handle_value(val); + return true; + } + + bool number_integer(number_integer_t val) + { + handle_value(val); + return true; + } + + bool number_unsigned(number_unsigned_t val) + { + handle_value(val); + return true; + } + + bool number_float(number_float_t val, const string_t& /*unused*/) + { + handle_value(val); + return true; + } + + bool string(string_t& val) + { + handle_value(val); + return true; + } + + bool binary(binary_t& val) + { + handle_value(std::move(val)); + return true; + } + + bool start_object(std::size_t len) + { + // check callback for object start + const bool keep = callback(static_cast(ref_stack.size()), parse_event_t::object_start, discarded); + keep_stack.push_back(keep); + + auto val = handle_value(BasicJsonType::value_t::object, true); + ref_stack.push_back(val.second); + + // check object limit + if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast(-1) && len > ref_stack.back()->max_size())) + { + JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back())); + } + + return true; + } + + bool key(string_t& val) + { + BasicJsonType k = BasicJsonType(val); + + // check callback for key + const bool keep = callback(static_cast(ref_stack.size()), parse_event_t::key, k); + key_keep_stack.push_back(keep); + + // add discarded value at given key and store the reference for later + if (keep && ref_stack.back()) + { + object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded); + } + + return true; + } + + bool end_object() + { + if (ref_stack.back()) + { + if (!callback(static_cast(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back())) + { + // discard object + *ref_stack.back() = discarded; + } + else + { + ref_stack.back()->set_parents(); + } + } + + JSON_ASSERT(!ref_stack.empty()); + JSON_ASSERT(!keep_stack.empty()); + ref_stack.pop_back(); + keep_stack.pop_back(); + + if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured()) + { + // remove discarded value + for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it) + { + if (it->is_discarded()) + { + ref_stack.back()->erase(it); + break; + } + } + } + + return true; + } + + bool start_array(std::size_t len) + { + const bool keep = callback(static_cast(ref_stack.size()), parse_event_t::array_start, discarded); + keep_stack.push_back(keep); + + auto val = handle_value(BasicJsonType::value_t::array, true); + ref_stack.push_back(val.second); + + // check array limit + if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast(-1) && len > ref_stack.back()->max_size())) + { + JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back())); + } + + return true; + } + + bool end_array() + { + bool keep = true; + + if (ref_stack.back()) + { + keep = callback(static_cast(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back()); + if (keep) + { + ref_stack.back()->set_parents(); + } + else + { + // discard array + *ref_stack.back() = discarded; + } + } + + JSON_ASSERT(!ref_stack.empty()); + JSON_ASSERT(!keep_stack.empty()); + ref_stack.pop_back(); + keep_stack.pop_back(); + + // remove discarded value + if (!keep && !ref_stack.empty() && ref_stack.back()->is_array()) + { + ref_stack.back()->m_data.m_value.array->pop_back(); + } + + return true; + } + + template + bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, + const Exception& ex) + { + errored = true; + static_cast(ex); + if (allow_exceptions) + { + JSON_THROW(ex); + } + return false; + } + + constexpr bool is_errored() const + { + return errored; + } + + private: + /*! + @param[in] v value to add to the JSON value we build during parsing + @param[in] skip_callback whether we should skip calling the callback + function; this is required after start_array() and + start_object() SAX events, because otherwise we would call the + callback function with an empty array or object, respectively. + + @invariant If the ref stack is empty, then the passed value will be the new + root. + @invariant If the ref stack contains a value, then it is an array or an + object to which we can add elements + + @return pair of boolean (whether value should be kept) and pointer (to the + passed value in the ref_stack hierarchy; nullptr if not kept) + */ + template + std::pair handle_value(Value&& v, const bool skip_callback = false) + { + JSON_ASSERT(!keep_stack.empty()); + + // do not handle this value if we know it would be added to a discarded + // container + if (!keep_stack.back()) + { + return {false, nullptr}; + } + + // create value + auto value = BasicJsonType(std::forward(v)); + + // check callback + const bool keep = skip_callback || callback(static_cast(ref_stack.size()), parse_event_t::value, value); + + // do not handle this value if we just learnt it shall be discarded + if (!keep) + { + return {false, nullptr}; + } + + if (ref_stack.empty()) + { + root = std::move(value); + return {true, & root}; + } + + // skip this value if we already decided to skip the parent + // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360) + if (!ref_stack.back()) + { + return {false, nullptr}; + } + + // we now only expect arrays and objects + JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); + + // array + if (ref_stack.back()->is_array()) + { + ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value)); + return {true, & (ref_stack.back()->m_data.m_value.array->back())}; + } + + // object + JSON_ASSERT(ref_stack.back()->is_object()); + // check if we should store an element for the current key + JSON_ASSERT(!key_keep_stack.empty()); + const bool store_element = key_keep_stack.back(); + key_keep_stack.pop_back(); + + if (!store_element) + { + return {false, nullptr}; + } + + JSON_ASSERT(object_element); + *object_element = std::move(value); + return {true, object_element}; + } + + /// the parsed JSON value + BasicJsonType& root; + /// stack to model hierarchy of values + std::vector ref_stack {}; + /// stack to manage which values to keep + std::vector keep_stack {}; + /// stack to manage which object keys to keep + std::vector key_keep_stack {}; + /// helper to hold the reference for the next object element + BasicJsonType* object_element = nullptr; + /// whether a syntax error occurred + bool errored = false; + /// callback function + const parser_callback_t callback = nullptr; + /// whether to throw exceptions in case of errors + const bool allow_exceptions = true; + /// a discarded value for the callback + BasicJsonType discarded = BasicJsonType::value_t::discarded; +}; + +template +class json_sax_acceptor +{ + public: + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + + bool null() + { + return true; + } + + bool boolean(bool /*unused*/) + { + return true; + } + + bool number_integer(number_integer_t /*unused*/) + { + return true; + } + + bool number_unsigned(number_unsigned_t /*unused*/) + { + return true; + } + + bool number_float(number_float_t /*unused*/, const string_t& /*unused*/) + { + return true; + } + + bool string(string_t& /*unused*/) + { + return true; + } + + bool binary(binary_t& /*unused*/) + { + return true; + } + + bool start_object(std::size_t /*unused*/ = static_cast(-1)) + { + return true; + } + + bool key(string_t& /*unused*/) + { + return true; + } + + bool end_object() + { + return true; + } + + bool start_array(std::size_t /*unused*/ = static_cast(-1)) + { + return true; + } + + bool end_array() + { + return true; + } + + bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/) + { + return false; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/lexer.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/lexer.hpp new file mode 100644 index 0000000..4b3bf77 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/lexer.hpp @@ -0,0 +1,1633 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // array +#include // localeconv +#include // size_t +#include // snprintf +#include // strtof, strtod, strtold, strtoll, strtoull +#include // initializer_list +#include // char_traits, string +#include // move +#include // vector + +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////// +// lexer // +/////////// + +template +class lexer_base +{ + public: + /// token types for the parser + enum class token_type + { + uninitialized, ///< indicating the scanner is uninitialized + literal_true, ///< the `true` literal + literal_false, ///< the `false` literal + literal_null, ///< the `null` literal + value_string, ///< a string -- use get_string() for actual value + value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for actual value + value_integer, ///< a signed integer -- use get_number_integer() for actual value + value_float, ///< an floating point number -- use get_number_float() for actual value + begin_array, ///< the character for array begin `[` + begin_object, ///< the character for object begin `{` + end_array, ///< the character for array end `]` + end_object, ///< the character for object end `}` + name_separator, ///< the name separator `:` + value_separator, ///< the value separator `,` + parse_error, ///< indicating a parse error + end_of_input, ///< indicating the end of the input buffer + literal_or_value ///< a literal or the begin of a value (only for diagnostics) + }; + + /// return name of values of type token_type (only used for errors) + JSON_HEDLEY_RETURNS_NON_NULL + JSON_HEDLEY_CONST + static const char* token_type_name(const token_type t) noexcept + { + switch (t) + { + case token_type::uninitialized: + return ""; + case token_type::literal_true: + return "true literal"; + case token_type::literal_false: + return "false literal"; + case token_type::literal_null: + return "null literal"; + case token_type::value_string: + return "string literal"; + case token_type::value_unsigned: + case token_type::value_integer: + case token_type::value_float: + return "number literal"; + case token_type::begin_array: + return "'['"; + case token_type::begin_object: + return "'{'"; + case token_type::end_array: + return "']'"; + case token_type::end_object: + return "'}'"; + case token_type::name_separator: + return "':'"; + case token_type::value_separator: + return "','"; + case token_type::parse_error: + return ""; + case token_type::end_of_input: + return "end of input"; + case token_type::literal_or_value: + return "'[', '{', or a literal"; + // LCOV_EXCL_START + default: // catch non-enum values + return "unknown token"; + // LCOV_EXCL_STOP + } + } +}; +/*! +@brief lexical analysis + +This class organizes the lexical analysis during JSON deserialization. +*/ +template +class lexer : public lexer_base +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using char_type = typename InputAdapterType::char_type; + using char_int_type = typename char_traits::int_type; + + public: + using token_type = typename lexer_base::token_type; + + explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept + : ia(std::move(adapter)) + , ignore_comments(ignore_comments_) + , decimal_point_char(static_cast(get_decimal_point())) + {} + + // delete because of pointer members + lexer(const lexer&) = delete; + lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + lexer& operator=(lexer&) = delete; + lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) + ~lexer() = default; + + private: + ///////////////////// + // locales + ///////////////////// + + /// return the locale-dependent decimal point + JSON_HEDLEY_PURE + static char get_decimal_point() noexcept + { + const auto* loc = localeconv(); + JSON_ASSERT(loc != nullptr); + return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point); + } + + ///////////////////// + // scan functions + ///////////////////// + + /*! + @brief get codepoint from 4 hex characters following `\u` + + For input "\u c1 c2 c3 c4" the codepoint is: + (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4 + = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0) + + Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f' + must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The + conversion is done by subtracting the offset (0x30, 0x37, and 0x57) + between the ASCII value of the character and the desired integer value. + + @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or + non-hex character) + */ + int get_codepoint() + { + // this function only makes sense after reading `\u` + JSON_ASSERT(current == 'u'); + int codepoint = 0; + + const auto factors = { 12u, 8u, 4u, 0u }; + for (const auto factor : factors) + { + get(); + + if (current >= '0' && current <= '9') + { + codepoint += static_cast((static_cast(current) - 0x30u) << factor); + } + else if (current >= 'A' && current <= 'F') + { + codepoint += static_cast((static_cast(current) - 0x37u) << factor); + } + else if (current >= 'a' && current <= 'f') + { + codepoint += static_cast((static_cast(current) - 0x57u) << factor); + } + else + { + return -1; + } + } + + JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF); + return codepoint; + } + + /*! + @brief check if the next byte(s) are inside a given range + + Adds the current byte and, for each passed range, reads a new byte and + checks if it is inside the range. If a violation was detected, set up an + error message and return false. Otherwise, return true. + + @param[in] ranges list of integers; interpreted as list of pairs of + inclusive lower and upper bound, respectively + + @pre The passed list @a ranges must have 2, 4, or 6 elements; that is, + 1, 2, or 3 pairs. This precondition is enforced by an assertion. + + @return true if and only if no range violation was detected + */ + bool next_byte_in_range(std::initializer_list ranges) + { + JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6); + add(current); + + for (auto range = ranges.begin(); range != ranges.end(); ++range) + { + get(); + if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions) + { + add(current); + } + else + { + error_message = "invalid string: ill-formed UTF-8 byte"; + return false; + } + } + + return true; + } + + /*! + @brief scan a string literal + + This function scans a string according to Sect. 7 of RFC 8259. While + scanning, bytes are escaped and copied into buffer token_buffer. Then the + function returns successfully, token_buffer is *not* null-terminated (as it + may contain \0 bytes), and token_buffer.size() is the number of bytes in the + string. + + @return token_type::value_string if string could be successfully scanned, + token_type::parse_error otherwise + + @note In case of errors, variable error_message contains a textual + description. + */ + token_type scan_string() + { + // reset token_buffer (ignore opening quote) + reset(); + + // we entered the function by reading an open quote + JSON_ASSERT(current == '\"'); + + while (true) + { + // get next character + switch (get()) + { + // end of file while parsing string + case char_traits::eof(): + { + error_message = "invalid string: missing closing quote"; + return token_type::parse_error; + } + + // closing quote + case '\"': + { + return token_type::value_string; + } + + // escapes + case '\\': + { + switch (get()) + { + // quotation mark + case '\"': + add('\"'); + break; + // reverse solidus + case '\\': + add('\\'); + break; + // solidus + case '/': + add('/'); + break; + // backspace + case 'b': + add('\b'); + break; + // form feed + case 'f': + add('\f'); + break; + // line feed + case 'n': + add('\n'); + break; + // carriage return + case 'r': + add('\r'); + break; + // tab + case 't': + add('\t'); + break; + + // unicode escapes + case 'u': + { + const int codepoint1 = get_codepoint(); + int codepoint = codepoint1; // start with codepoint1 + + if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1)) + { + error_message = "invalid string: '\\u' must be followed by 4 hex digits"; + return token_type::parse_error; + } + + // check if code point is a high surrogate + if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF) + { + // expect next \uxxxx entry + if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u')) + { + const int codepoint2 = get_codepoint(); + + if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1)) + { + error_message = "invalid string: '\\u' must be followed by 4 hex digits"; + return token_type::parse_error; + } + + // check if codepoint2 is a low surrogate + if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF)) + { + // overwrite codepoint + codepoint = static_cast( + // high surrogate occupies the most significant 22 bits + (static_cast(codepoint1) << 10u) + // low surrogate occupies the least significant 15 bits + + static_cast(codepoint2) + // there is still the 0xD800, 0xDC00 and 0x10000 noise + // in the result, so we have to subtract with: + // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00 + - 0x35FDC00u); + } + else + { + error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"; + return token_type::parse_error; + } + } + else + { + error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"; + return token_type::parse_error; + } + } + else + { + if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF)) + { + error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF"; + return token_type::parse_error; + } + } + + // result of the above calculation yields a proper codepoint + JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF); + + // translate codepoint into bytes + if (codepoint < 0x80) + { + // 1-byte characters: 0xxxxxxx (ASCII) + add(static_cast(codepoint)); + } + else if (codepoint <= 0x7FF) + { + // 2-byte characters: 110xxxxx 10xxxxxx + add(static_cast(0xC0u | (static_cast(codepoint) >> 6u))); + add(static_cast(0x80u | (static_cast(codepoint) & 0x3Fu))); + } + else if (codepoint <= 0xFFFF) + { + // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx + add(static_cast(0xE0u | (static_cast(codepoint) >> 12u))); + add(static_cast(0x80u | ((static_cast(codepoint) >> 6u) & 0x3Fu))); + add(static_cast(0x80u | (static_cast(codepoint) & 0x3Fu))); + } + else + { + // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + add(static_cast(0xF0u | (static_cast(codepoint) >> 18u))); + add(static_cast(0x80u | ((static_cast(codepoint) >> 12u) & 0x3Fu))); + add(static_cast(0x80u | ((static_cast(codepoint) >> 6u) & 0x3Fu))); + add(static_cast(0x80u | (static_cast(codepoint) & 0x3Fu))); + } + + break; + } + + // other characters after escape + default: + error_message = "invalid string: forbidden character after backslash"; + return token_type::parse_error; + } + + break; + } + + // invalid control characters + case 0x00: + { + error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000"; + return token_type::parse_error; + } + + case 0x01: + { + error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001"; + return token_type::parse_error; + } + + case 0x02: + { + error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002"; + return token_type::parse_error; + } + + case 0x03: + { + error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003"; + return token_type::parse_error; + } + + case 0x04: + { + error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004"; + return token_type::parse_error; + } + + case 0x05: + { + error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005"; + return token_type::parse_error; + } + + case 0x06: + { + error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006"; + return token_type::parse_error; + } + + case 0x07: + { + error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007"; + return token_type::parse_error; + } + + case 0x08: + { + error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b"; + return token_type::parse_error; + } + + case 0x09: + { + error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t"; + return token_type::parse_error; + } + + case 0x0A: + { + error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n"; + return token_type::parse_error; + } + + case 0x0B: + { + error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B"; + return token_type::parse_error; + } + + case 0x0C: + { + error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f"; + return token_type::parse_error; + } + + case 0x0D: + { + error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r"; + return token_type::parse_error; + } + + case 0x0E: + { + error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E"; + return token_type::parse_error; + } + + case 0x0F: + { + error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F"; + return token_type::parse_error; + } + + case 0x10: + { + error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010"; + return token_type::parse_error; + } + + case 0x11: + { + error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011"; + return token_type::parse_error; + } + + case 0x12: + { + error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012"; + return token_type::parse_error; + } + + case 0x13: + { + error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013"; + return token_type::parse_error; + } + + case 0x14: + { + error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014"; + return token_type::parse_error; + } + + case 0x15: + { + error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015"; + return token_type::parse_error; + } + + case 0x16: + { + error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016"; + return token_type::parse_error; + } + + case 0x17: + { + error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017"; + return token_type::parse_error; + } + + case 0x18: + { + error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018"; + return token_type::parse_error; + } + + case 0x19: + { + error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019"; + return token_type::parse_error; + } + + case 0x1A: + { + error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A"; + return token_type::parse_error; + } + + case 0x1B: + { + error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B"; + return token_type::parse_error; + } + + case 0x1C: + { + error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C"; + return token_type::parse_error; + } + + case 0x1D: + { + error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D"; + return token_type::parse_error; + } + + case 0x1E: + { + error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E"; + return token_type::parse_error; + } + + case 0x1F: + { + error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F"; + return token_type::parse_error; + } + + // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace)) + case 0x20: + case 0x21: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + case 0x28: + case 0x29: + case 0x2A: + case 0x2B: + case 0x2C: + case 0x2D: + case 0x2E: + case 0x2F: + case 0x30: + case 0x31: + case 0x32: + case 0x33: + case 0x34: + case 0x35: + case 0x36: + case 0x37: + case 0x38: + case 0x39: + case 0x3A: + case 0x3B: + case 0x3C: + case 0x3D: + case 0x3E: + case 0x3F: + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4A: + case 0x4B: + case 0x4C: + case 0x4D: + case 0x4E: + case 0x4F: + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + case 0x58: + case 0x59: + case 0x5A: + case 0x5B: + case 0x5D: + case 0x5E: + case 0x5F: + case 0x60: + case 0x61: + case 0x62: + case 0x63: + case 0x64: + case 0x65: + case 0x66: + case 0x67: + case 0x68: + case 0x69: + case 0x6A: + case 0x6B: + case 0x6C: + case 0x6D: + case 0x6E: + case 0x6F: + case 0x70: + case 0x71: + case 0x72: + case 0x73: + case 0x74: + case 0x75: + case 0x76: + case 0x77: + case 0x78: + case 0x79: + case 0x7A: + case 0x7B: + case 0x7C: + case 0x7D: + case 0x7E: + case 0x7F: + { + add(current); + break; + } + + // U+0080..U+07FF: bytes C2..DF 80..BF + case 0xC2: + case 0xC3: + case 0xC4: + case 0xC5: + case 0xC6: + case 0xC7: + case 0xC8: + case 0xC9: + case 0xCA: + case 0xCB: + case 0xCC: + case 0xCD: + case 0xCE: + case 0xCF: + case 0xD0: + case 0xD1: + case 0xD2: + case 0xD3: + case 0xD4: + case 0xD5: + case 0xD6: + case 0xD7: + case 0xD8: + case 0xD9: + case 0xDA: + case 0xDB: + case 0xDC: + case 0xDD: + case 0xDE: + case 0xDF: + { + if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF}))) + { + return token_type::parse_error; + } + break; + } + + // U+0800..U+0FFF: bytes E0 A0..BF 80..BF + case 0xE0: + { + if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF + // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF + case 0xE1: + case 0xE2: + case 0xE3: + case 0xE4: + case 0xE5: + case 0xE6: + case 0xE7: + case 0xE8: + case 0xE9: + case 0xEA: + case 0xEB: + case 0xEC: + case 0xEE: + case 0xEF: + { + if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+D000..U+D7FF: bytes ED 80..9F 80..BF + case 0xED: + { + if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF + case 0xF0: + { + if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF + case 0xF1: + case 0xF2: + case 0xF3: + { + if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF + case 0xF4: + { + if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // remaining bytes (80..C1 and F5..FF) are ill-formed + default: + { + error_message = "invalid string: ill-formed UTF-8 byte"; + return token_type::parse_error; + } + } + } + } + + /*! + * @brief scan a comment + * @return whether comment could be scanned successfully + */ + bool scan_comment() + { + switch (get()) + { + // single-line comments skip input until a newline or EOF is read + case '/': + { + while (true) + { + switch (get()) + { + case '\n': + case '\r': + case char_traits::eof(): + case '\0': + return true; + + default: + break; + } + } + } + + // multi-line comments skip input until */ is read + case '*': + { + while (true) + { + switch (get()) + { + case char_traits::eof(): + case '\0': + { + error_message = "invalid comment; missing closing '*/'"; + return false; + } + + case '*': + { + switch (get()) + { + case '/': + return true; + + default: + { + unget(); + continue; + } + } + } + + default: + continue; + } + } + } + + // unexpected character after reading '/' + default: + { + error_message = "invalid comment; expecting '/' or '*' after '/'"; + return false; + } + } + } + + JSON_HEDLEY_NON_NULL(2) + static void strtof(float& f, const char* str, char** endptr) noexcept + { + f = std::strtof(str, endptr); + } + + JSON_HEDLEY_NON_NULL(2) + static void strtof(double& f, const char* str, char** endptr) noexcept + { + f = std::strtod(str, endptr); + } + + JSON_HEDLEY_NON_NULL(2) + static void strtof(long double& f, const char* str, char** endptr) noexcept + { + f = std::strtold(str, endptr); + } + + /*! + @brief scan a number literal + + This function scans a string according to Sect. 6 of RFC 8259. + + The function is realized with a deterministic finite state machine derived + from the grammar described in RFC 8259. Starting in state "init", the + input is read and used to determined the next state. Only state "done" + accepts the number. State "error" is a trap state to model errors. In the + table below, "anything" means any character but the ones listed before. + + state | 0 | 1-9 | e E | + | - | . | anything + ---------|----------|----------|----------|---------|---------|----------|----------- + init | zero | any1 | [error] | [error] | minus | [error] | [error] + minus | zero | any1 | [error] | [error] | [error] | [error] | [error] + zero | done | done | exponent | done | done | decimal1 | done + any1 | any1 | any1 | exponent | done | done | decimal1 | done + decimal1 | decimal2 | decimal2 | [error] | [error] | [error] | [error] | [error] + decimal2 | decimal2 | decimal2 | exponent | done | done | done | done + exponent | any2 | any2 | [error] | sign | sign | [error] | [error] + sign | any2 | any2 | [error] | [error] | [error] | [error] | [error] + any2 | any2 | any2 | done | done | done | done | done + + The state machine is realized with one label per state (prefixed with + "scan_number_") and `goto` statements between them. The state machine + contains cycles, but any cycle can be left when EOF is read. Therefore, + the function is guaranteed to terminate. + + During scanning, the read bytes are stored in token_buffer. This string is + then converted to a signed integer, an unsigned integer, or a + floating-point number. + + @return token_type::value_unsigned, token_type::value_integer, or + token_type::value_float if number could be successfully scanned, + token_type::parse_error otherwise + + @note The scanner is independent of the current locale. Internally, the + locale's decimal point is used instead of `.` to work with the + locale-dependent converters. + */ + token_type scan_number() // lgtm [cpp/use-of-goto] + { + // reset token_buffer to store the number's bytes + reset(); + + // the type of the parsed number; initially set to unsigned; will be + // changed if minus sign, decimal point or exponent is read + token_type number_type = token_type::value_unsigned; + + // state (init): we just found out we need to scan a number + switch (current) + { + case '-': + { + add(current); + goto scan_number_minus; + } + + case '0': + { + add(current); + goto scan_number_zero; + } + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any1; + } + + // all other characters are rejected outside scan_number() + default: // LCOV_EXCL_LINE + JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE + } + +scan_number_minus: + // state: we just parsed a leading minus sign + number_type = token_type::value_integer; + switch (get()) + { + case '0': + { + add(current); + goto scan_number_zero; + } + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any1; + } + + default: + { + error_message = "invalid number; expected digit after '-'"; + return token_type::parse_error; + } + } + +scan_number_zero: + // state: we just parse a zero (maybe with a leading minus sign) + switch (get()) + { + case '.': + { + add(decimal_point_char); + goto scan_number_decimal1; + } + + case 'e': + case 'E': + { + add(current); + goto scan_number_exponent; + } + + default: + goto scan_number_done; + } + +scan_number_any1: + // state: we just parsed a number 0-9 (maybe with a leading minus sign) + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any1; + } + + case '.': + { + add(decimal_point_char); + goto scan_number_decimal1; + } + + case 'e': + case 'E': + { + add(current); + goto scan_number_exponent; + } + + default: + goto scan_number_done; + } + +scan_number_decimal1: + // state: we just parsed a decimal point + number_type = token_type::value_float; + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_decimal2; + } + + default: + { + error_message = "invalid number; expected digit after '.'"; + return token_type::parse_error; + } + } + +scan_number_decimal2: + // we just parsed at least one number after a decimal point + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_decimal2; + } + + case 'e': + case 'E': + { + add(current); + goto scan_number_exponent; + } + + default: + goto scan_number_done; + } + +scan_number_exponent: + // we just parsed an exponent + number_type = token_type::value_float; + switch (get()) + { + case '+': + case '-': + { + add(current); + goto scan_number_sign; + } + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any2; + } + + default: + { + error_message = + "invalid number; expected '+', '-', or digit after exponent"; + return token_type::parse_error; + } + } + +scan_number_sign: + // we just parsed an exponent sign + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any2; + } + + default: + { + error_message = "invalid number; expected digit after exponent sign"; + return token_type::parse_error; + } + } + +scan_number_any2: + // we just parsed a number after the exponent or exponent sign + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any2; + } + + default: + goto scan_number_done; + } + +scan_number_done: + // unget the character after the number (we only read it to know that + // we are done scanning a number) + unget(); + + char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) + errno = 0; + + // try to parse integers first and fall back to floats + if (number_type == token_type::value_unsigned) + { + const auto x = std::strtoull(token_buffer.data(), &endptr, 10); + + // we checked the number format before + JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); + + if (errno == 0) + { + value_unsigned = static_cast(x); + if (value_unsigned == x) + { + return token_type::value_unsigned; + } + } + } + else if (number_type == token_type::value_integer) + { + const auto x = std::strtoll(token_buffer.data(), &endptr, 10); + + // we checked the number format before + JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); + + if (errno == 0) + { + value_integer = static_cast(x); + if (value_integer == x) + { + return token_type::value_integer; + } + } + } + + // this code is reached if we parse a floating-point number or if an + // integer conversion above failed + strtof(value_float, token_buffer.data(), &endptr); + + // we checked the number format before + JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); + + return token_type::value_float; + } + + /*! + @param[in] literal_text the literal text to expect + @param[in] length the length of the passed literal text + @param[in] return_type the token type to return on success + */ + JSON_HEDLEY_NON_NULL(2) + token_type scan_literal(const char_type* literal_text, const std::size_t length, + token_type return_type) + { + JSON_ASSERT(char_traits::to_char_type(current) == literal_text[0]); + for (std::size_t i = 1; i < length; ++i) + { + if (JSON_HEDLEY_UNLIKELY(char_traits::to_char_type(get()) != literal_text[i])) + { + error_message = "invalid literal"; + return token_type::parse_error; + } + } + return return_type; + } + + ///////////////////// + // input management + ///////////////////// + + /// reset token_buffer; current character is beginning of token + void reset() noexcept + { + token_buffer.clear(); + token_string.clear(); + token_string.push_back(char_traits::to_char_type(current)); + } + + /* + @brief get next character from the input + + This function provides the interface to the used input adapter. It does + not throw in case the input reached EOF, but returns a + `char_traits::eof()` in that case. Stores the scanned characters + for use in error messages. + + @return character read from the input + */ + char_int_type get() + { + ++position.chars_read_total; + ++position.chars_read_current_line; + + if (next_unget) + { + // just reset the next_unget variable and work with current + next_unget = false; + } + else + { + current = ia.get_character(); + } + + if (JSON_HEDLEY_LIKELY(current != char_traits::eof())) + { + token_string.push_back(char_traits::to_char_type(current)); + } + + if (current == '\n') + { + ++position.lines_read; + position.chars_read_current_line = 0; + } + + return current; + } + + /*! + @brief unget current character (read it again on next get) + + We implement unget by setting variable next_unget to true. The input is not + changed - we just simulate ungetting by modifying chars_read_total, + chars_read_current_line, and token_string. The next call to get() will + behave as if the unget character is read again. + */ + void unget() + { + next_unget = true; + + --position.chars_read_total; + + // in case we "unget" a newline, we have to also decrement the lines_read + if (position.chars_read_current_line == 0) + { + if (position.lines_read > 0) + { + --position.lines_read; + } + } + else + { + --position.chars_read_current_line; + } + + if (JSON_HEDLEY_LIKELY(current != char_traits::eof())) + { + JSON_ASSERT(!token_string.empty()); + token_string.pop_back(); + } + } + + /// add a character to token_buffer + void add(char_int_type c) + { + token_buffer.push_back(static_cast(c)); + } + + public: + ///////////////////// + // value getters + ///////////////////// + + /// return integer value + constexpr number_integer_t get_number_integer() const noexcept + { + return value_integer; + } + + /// return unsigned integer value + constexpr number_unsigned_t get_number_unsigned() const noexcept + { + return value_unsigned; + } + + /// return floating-point value + constexpr number_float_t get_number_float() const noexcept + { + return value_float; + } + + /// return current string value (implicitly resets the token; useful only once) + string_t& get_string() + { + return token_buffer; + } + + ///////////////////// + // diagnostics + ///////////////////// + + /// return position of last read token + constexpr position_t get_position() const noexcept + { + return position; + } + + /// return the last read token (for errors only). Will never contain EOF + /// (an arbitrary value that is not a valid char value, often -1), because + /// 255 may legitimately occur. May contain NUL, which should be escaped. + std::string get_token_string() const + { + // escape control characters + std::string result; + for (const auto c : token_string) + { + if (static_cast(c) <= '\x1F') + { + // escape control characters + std::array cs{{}}; + static_cast((std::snprintf)(cs.data(), cs.size(), "", static_cast(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) + result += cs.data(); + } + else + { + // add character as is + result.push_back(static_cast(c)); + } + } + + return result; + } + + /// return syntax error message + JSON_HEDLEY_RETURNS_NON_NULL + constexpr const char* get_error_message() const noexcept + { + return error_message; + } + + ///////////////////// + // actual scanner + ///////////////////// + + /*! + @brief skip the UTF-8 byte order mark + @return true iff there is no BOM or the correct BOM has been skipped + */ + bool skip_bom() + { + if (get() == 0xEF) + { + // check if we completely parse the BOM + return get() == 0xBB && get() == 0xBF; + } + + // the first character is not the beginning of the BOM; unget it to + // process is later + unget(); + return true; + } + + void skip_whitespace() + { + do + { + get(); + } + while (current == ' ' || current == '\t' || current == '\n' || current == '\r'); + } + + token_type scan() + { + // initially, skip the BOM + if (position.chars_read_total == 0 && !skip_bom()) + { + error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given"; + return token_type::parse_error; + } + + // read next character and ignore whitespace + skip_whitespace(); + + // ignore comments + while (ignore_comments && current == '/') + { + if (!scan_comment()) + { + return token_type::parse_error; + } + + // skip following whitespace + skip_whitespace(); + } + + switch (current) + { + // structural characters + case '[': + return token_type::begin_array; + case ']': + return token_type::end_array; + case '{': + return token_type::begin_object; + case '}': + return token_type::end_object; + case ':': + return token_type::name_separator; + case ',': + return token_type::value_separator; + + // literals + case 't': + { + std::array true_literal = {{static_cast('t'), static_cast('r'), static_cast('u'), static_cast('e')}}; + return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true); + } + case 'f': + { + std::array false_literal = {{static_cast('f'), static_cast('a'), static_cast('l'), static_cast('s'), static_cast('e')}}; + return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false); + } + case 'n': + { + std::array null_literal = {{static_cast('n'), static_cast('u'), static_cast('l'), static_cast('l')}}; + return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null); + } + + // string + case '\"': + return scan_string(); + + // number + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return scan_number(); + + // end of input (the null byte is needed when parsing from + // string literals) + case '\0': + case char_traits::eof(): + return token_type::end_of_input; + + // error + default: + error_message = "invalid literal"; + return token_type::parse_error; + } + } + + private: + /// input adapter + InputAdapterType ia; + + /// whether comments should be ignored (true) or signaled as errors (false) + const bool ignore_comments = false; + + /// the current character + char_int_type current = char_traits::eof(); + + /// whether the next get() call should just return current + bool next_unget = false; + + /// the start position of the current token + position_t position {}; + + /// raw input token string (for error messages) + std::vector token_string {}; + + /// buffer for variable-length tokens (numbers, strings) + string_t token_buffer {}; + + /// a description of occurred lexer errors + const char* error_message = ""; + + // number values + number_integer_t value_integer = 0; + number_unsigned_t value_unsigned = 0; + number_float_t value_float = 0; + + /// the decimal point + const char_int_type decimal_point_char = '.'; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/parser.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/parser.hpp new file mode 100644 index 0000000..bdf85ba --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/parser.hpp @@ -0,0 +1,519 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // isfinite +#include // uint8_t +#include // function +#include // string +#include // move +#include // vector + +#include +#include +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ +//////////// +// parser // +//////////// + +enum class parse_event_t : std::uint8_t +{ + /// the parser read `{` and started to process a JSON object + object_start, + /// the parser read `}` and finished processing a JSON object + object_end, + /// the parser read `[` and started to process a JSON array + array_start, + /// the parser read `]` and finished processing a JSON array + array_end, + /// the parser read a key of a value in an object + key, + /// the parser finished reading a JSON value + value +}; + +template +using parser_callback_t = + std::function; + +/*! +@brief syntax analysis + +This class implements a recursive descent parser. +*/ +template +class parser +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using lexer_t = lexer; + using token_type = typename lexer_t::token_type; + + public: + /// a parser reading from an input adapter + explicit parser(InputAdapterType&& adapter, + const parser_callback_t cb = nullptr, + const bool allow_exceptions_ = true, + const bool skip_comments = false) + : callback(cb) + , m_lexer(std::move(adapter), skip_comments) + , allow_exceptions(allow_exceptions_) + { + // read first token + get_token(); + } + + /*! + @brief public parser interface + + @param[in] strict whether to expect the last token to be EOF + @param[in,out] result parsed JSON value + + @throw parse_error.101 in case of an unexpected token + @throw parse_error.102 if to_unicode fails or surrogate error + @throw parse_error.103 if to_unicode fails + */ + void parse(const bool strict, BasicJsonType& result) + { + if (callback) + { + json_sax_dom_callback_parser sdp(result, callback, allow_exceptions); + sax_parse_internal(&sdp); + + // in strict mode, input must be completely read + if (strict && (get_token() != token_type::end_of_input)) + { + sdp.parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), + exception_message(token_type::end_of_input, "value"), nullptr)); + } + + // in case of an error, return discarded value + if (sdp.is_errored()) + { + result = value_t::discarded; + return; + } + + // set top-level value to null if it was discarded by the callback + // function + if (result.is_discarded()) + { + result = nullptr; + } + } + else + { + json_sax_dom_parser sdp(result, allow_exceptions); + sax_parse_internal(&sdp); + + // in strict mode, input must be completely read + if (strict && (get_token() != token_type::end_of_input)) + { + sdp.parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr)); + } + + // in case of an error, return discarded value + if (sdp.is_errored()) + { + result = value_t::discarded; + return; + } + } + + result.assert_invariant(); + } + + /*! + @brief public accept interface + + @param[in] strict whether to expect the last token to be EOF + @return whether the input is a proper JSON text + */ + bool accept(const bool strict = true) + { + json_sax_acceptor sax_acceptor; + return sax_parse(&sax_acceptor, strict); + } + + template + JSON_HEDLEY_NON_NULL(2) + bool sax_parse(SAX* sax, const bool strict = true) + { + (void)detail::is_sax_static_asserts {}; + const bool result = sax_parse_internal(sax); + + // strict mode: next byte must be EOF + if (result && strict && (get_token() != token_type::end_of_input)) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr)); + } + + return result; + } + + private: + template + JSON_HEDLEY_NON_NULL(2) + bool sax_parse_internal(SAX* sax) + { + // stack to remember the hierarchy of structured values we are parsing + // true = array; false = object + std::vector states; + // value to avoid a goto (see comment where set to true) + bool skip_to_state_evaluation = false; + + while (true) + { + if (!skip_to_state_evaluation) + { + // invariant: get_token() was called before each iteration + switch (last_token) + { + case token_type::begin_object: + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast(-1)))) + { + return false; + } + + // closing } -> we are done + if (get_token() == token_type::end_object) + { + if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) + { + return false; + } + break; + } + + // parse key + if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string)) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr)); + } + if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) + { + return false; + } + + // parse separator (:) + if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr)); + } + + // remember we are now inside an object + states.push_back(false); + + // parse values + get_token(); + continue; + } + + case token_type::begin_array: + { + if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast(-1)))) + { + return false; + } + + // closing ] -> we are done + if (get_token() == token_type::end_array) + { + if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) + { + return false; + } + break; + } + + // remember we are now inside an array + states.push_back(true); + + // parse values (no need to call get_token) + continue; + } + + case token_type::value_float: + { + const auto res = m_lexer.get_number_float(); + + if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res))) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr)); + } + + if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string()))) + { + return false; + } + + break; + } + + case token_type::literal_false: + { + if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false))) + { + return false; + } + break; + } + + case token_type::literal_null: + { + if (JSON_HEDLEY_UNLIKELY(!sax->null())) + { + return false; + } + break; + } + + case token_type::literal_true: + { + if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true))) + { + return false; + } + break; + } + + case token_type::value_integer: + { + if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer()))) + { + return false; + } + break; + } + + case token_type::value_string: + { + if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string()))) + { + return false; + } + break; + } + + case token_type::value_unsigned: + { + if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned()))) + { + return false; + } + break; + } + + case token_type::parse_error: + { + // using "uninitialized" to avoid "expected" message + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr)); + } + case token_type::end_of_input: + { + if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1)) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), + "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr)); + } + + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr)); + } + case token_type::uninitialized: + case token_type::end_array: + case token_type::end_object: + case token_type::name_separator: + case token_type::value_separator: + case token_type::literal_or_value: + default: // the last token was unexpected + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr)); + } + } + } + else + { + skip_to_state_evaluation = false; + } + + // we reached this line after we successfully parsed a value + if (states.empty()) + { + // empty stack: we reached the end of the hierarchy: done + return true; + } + + if (states.back()) // array + { + // comma -> next value + if (get_token() == token_type::value_separator) + { + // parse a new value + get_token(); + continue; + } + + // closing ] + if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array)) + { + if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) + { + return false; + } + + // We are done with this array. Before we can parse a + // new value, we need to evaluate the new state first. + // By setting skip_to_state_evaluation to false, we + // are effectively jumping to the beginning of this if. + JSON_ASSERT(!states.empty()); + states.pop_back(); + skip_to_state_evaluation = true; + continue; + } + + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr)); + } + + // states.back() is false -> object + + // comma -> next value + if (get_token() == token_type::value_separator) + { + // parse key + if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string)) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr)); + } + + if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) + { + return false; + } + + // parse separator (:) + if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) + { + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr)); + } + + // parse values + get_token(); + continue; + } + + // closing } + if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object)) + { + if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) + { + return false; + } + + // We are done with this object. Before we can parse a + // new value, we need to evaluate the new state first. + // By setting skip_to_state_evaluation to false, we + // are effectively jumping to the beginning of this if. + JSON_ASSERT(!states.empty()); + states.pop_back(); + skip_to_state_evaluation = true; + continue; + } + + return sax->parse_error(m_lexer.get_position(), + m_lexer.get_token_string(), + parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr)); + } + } + + /// get next token from lexer + token_type get_token() + { + return last_token = m_lexer.scan(); + } + + std::string exception_message(const token_type expected, const std::string& context) + { + std::string error_msg = "syntax error "; + + if (!context.empty()) + { + error_msg += concat("while parsing ", context, ' '); + } + + error_msg += "- "; + + if (last_token == token_type::parse_error) + { + error_msg += concat(m_lexer.get_error_message(), "; last read: '", + m_lexer.get_token_string(), '\''); + } + else + { + error_msg += concat("unexpected ", lexer_t::token_type_name(last_token)); + } + + if (expected != token_type::uninitialized) + { + error_msg += concat("; expected ", lexer_t::token_type_name(expected)); + } + + return error_msg; + } + + private: + /// callback function + const parser_callback_t callback = nullptr; + /// the type of the last read token + token_type last_token = token_type::uninitialized; + /// the lexer + lexer_t m_lexer; + /// whether to throw exceptions in case of errors + const bool allow_exceptions = true; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/position_t.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/position_t.hpp new file mode 100644 index 0000000..8ac7c78 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/input/position_t.hpp @@ -0,0 +1,37 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // size_t + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/internal_iterator.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/internal_iterator.hpp new file mode 100644 index 0000000..2991ee6 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/internal_iterator.hpp @@ -0,0 +1,35 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief an iterator value + +@note This structure could easily be a union, but MSVC currently does not allow +unions members with complex constructors, see https://github.com/nlohmann/json/pull/105. +*/ +template struct internal_iterator +{ + /// iterator for JSON objects + typename BasicJsonType::object_t::iterator object_iterator {}; + /// iterator for JSON arrays + typename BasicJsonType::array_t::iterator array_iterator {}; + /// generic iterator for all other types + primitive_iterator_t primitive_iterator {}; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iter_impl.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iter_impl.hpp new file mode 100644 index 0000000..4447091 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iter_impl.hpp @@ -0,0 +1,751 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next +#include // conditional, is_const, remove_const + +#include +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// forward declare, to be able to friend it later on +template class iteration_proxy; +template class iteration_proxy_value; + +/*! +@brief a template for a bidirectional iterator for the @ref basic_json class +This class implements a both iterators (iterator and const_iterator) for the +@ref basic_json class. +@note An iterator is called *initialized* when a pointer to a JSON value has + been set (e.g., by a constructor or a copy assignment). If the iterator is + default-constructed, it is *uninitialized* and most methods are undefined. + **The library uses assertions to detect calls on uninitialized iterators.** +@requirement The class satisfies the following concept requirements: +- +[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator): + The iterator that can be moved can be moved in both directions (i.e. + incremented and decremented). +@since version 1.0.0, simplified in version 2.0.9, change to bidirectional + iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593) +*/ +template +class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions) +{ + /// the iterator with BasicJsonType of different const-ness + using other_iter_impl = iter_impl::value, typename std::remove_const::type, const BasicJsonType>::type>; + /// allow basic_json to access private members + friend other_iter_impl; + friend BasicJsonType; + friend iteration_proxy; + friend iteration_proxy_value; + + using object_t = typename BasicJsonType::object_t; + using array_t = typename BasicJsonType::array_t; + // make sure BasicJsonType is basic_json or const basic_json + static_assert(is_basic_json::type>::value, + "iter_impl only accepts (const) basic_json"); + // superficial check for the LegacyBidirectionalIterator named requirement + static_assert(std::is_base_of::value + && std::is_base_of::iterator_category>::value, + "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement."); + + public: + /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17. + /// The C++ Standard has never required user-defined iterators to derive from std::iterator. + /// A user-defined iterator should provide publicly accessible typedefs named + /// iterator_category, value_type, difference_type, pointer, and reference. + /// Note that value_type is required to be non-const, even for constant iterators. + using iterator_category = std::bidirectional_iterator_tag; + + /// the type of the values when the iterator is dereferenced + using value_type = typename BasicJsonType::value_type; + /// a type to represent differences between iterators + using difference_type = typename BasicJsonType::difference_type; + /// defines a pointer to the type iterated over (value_type) + using pointer = typename std::conditional::value, + typename BasicJsonType::const_pointer, + typename BasicJsonType::pointer>::type; + /// defines a reference to the type iterated over (value_type) + using reference = + typename std::conditional::value, + typename BasicJsonType::const_reference, + typename BasicJsonType::reference>::type; + + iter_impl() = default; + ~iter_impl() = default; + iter_impl(iter_impl&&) noexcept = default; + iter_impl& operator=(iter_impl&&) noexcept = default; + + /*! + @brief constructor for a given JSON instance + @param[in] object pointer to a JSON object for this iterator + @pre object != nullptr + @post The iterator is initialized; i.e. `m_object != nullptr`. + */ + explicit iter_impl(pointer object) noexcept : m_object(object) + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + m_it.object_iterator = typename object_t::iterator(); + break; + } + + case value_t::array: + { + m_it.array_iterator = typename array_t::iterator(); + break; + } + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + m_it.primitive_iterator = primitive_iterator_t(); + break; + } + } + } + + /*! + @note The conventional copy constructor and copy assignment are implicitly + defined. Combined with the following converting constructor and + assignment, they support: (1) copy from iterator to iterator, (2) + copy from const iterator to const iterator, and (3) conversion from + iterator to const iterator. However conversion from const iterator + to iterator is not defined. + */ + + /*! + @brief const copy constructor + @param[in] other const iterator to copy from + @note This copy constructor had to be defined explicitly to circumvent a bug + occurring on msvc v19.0 compiler (VS 2015) debug build. For more + information refer to: https://github.com/nlohmann/json/issues/1608 + */ + iter_impl(const iter_impl& other) noexcept + : m_object(other.m_object), m_it(other.m_it) + {} + + /*! + @brief converting assignment + @param[in] other const iterator to copy from + @return const/non-const iterator + @note It is not checked whether @a other is initialized. + */ + iter_impl& operator=(const iter_impl& other) noexcept + { + if (&other != this) + { + m_object = other.m_object; + m_it = other.m_it; + } + return *this; + } + + /*! + @brief converting constructor + @param[in] other non-const iterator to copy from + @note It is not checked whether @a other is initialized. + */ + iter_impl(const iter_impl::type>& other) noexcept + : m_object(other.m_object), m_it(other.m_it) + {} + + /*! + @brief converting assignment + @param[in] other non-const iterator to copy from + @return const/non-const iterator + @note It is not checked whether @a other is initialized. + */ + iter_impl& operator=(const iter_impl::type>& other) noexcept // NOLINT(cert-oop54-cpp) + { + m_object = other.m_object; + m_it = other.m_it; + return *this; + } + + JSON_PRIVATE_UNLESS_TESTED: + /*! + @brief set the iterator to the first value + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + void set_begin() noexcept + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + m_it.object_iterator = m_object->m_data.m_value.object->begin(); + break; + } + + case value_t::array: + { + m_it.array_iterator = m_object->m_data.m_value.array->begin(); + break; + } + + case value_t::null: + { + // set to end so begin()==end() is true: null is empty + m_it.primitive_iterator.set_end(); + break; + } + + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + m_it.primitive_iterator.set_begin(); + break; + } + } + } + + /*! + @brief set the iterator past the last value + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + void set_end() noexcept + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + m_it.object_iterator = m_object->m_data.m_value.object->end(); + break; + } + + case value_t::array: + { + m_it.array_iterator = m_object->m_data.m_value.array->end(); + break; + } + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + m_it.primitive_iterator.set_end(); + break; + } + } + } + + public: + /*! + @brief return a reference to the value pointed to by the iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + reference operator*() const + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end()); + return m_it.object_iterator->second; + } + + case value_t::array: + { + JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end()); + return *m_it.array_iterator; + } + + case value_t::null: + JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); + + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) + { + return *m_object; + } + + JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); + } + } + } + + /*! + @brief dereference the iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + pointer operator->() const + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end()); + return &(m_it.object_iterator->second); + } + + case value_t::array: + { + JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end()); + return &*m_it.array_iterator; + } + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) + { + return m_object; + } + + JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); + } + } + } + + /*! + @brief post-increment (it++) + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp) + { + auto result = *this; + ++(*this); + return result; + } + + /*! + @brief pre-increment (++it) + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl& operator++() + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + std::advance(m_it.object_iterator, 1); + break; + } + + case value_t::array: + { + std::advance(m_it.array_iterator, 1); + break; + } + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + ++m_it.primitive_iterator; + break; + } + } + + return *this; + } + + /*! + @brief post-decrement (it--) + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp) + { + auto result = *this; + --(*this); + return result; + } + + /*! + @brief pre-decrement (--it) + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl& operator--() + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + { + std::advance(m_it.object_iterator, -1); + break; + } + + case value_t::array: + { + std::advance(m_it.array_iterator, -1); + break; + } + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + --m_it.primitive_iterator; + break; + } + } + + return *this; + } + + /*! + @brief comparison: equal + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + template < typename IterImpl, detail::enable_if_t < (std::is_same::value || std::is_same::value), std::nullptr_t > = nullptr > + bool operator==(const IterImpl& other) const + { + // if objects are not the same, the comparison is undefined + if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) + { + JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object)); + } + + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + return (m_it.object_iterator == other.m_it.object_iterator); + + case value_t::array: + return (m_it.array_iterator == other.m_it.array_iterator); + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + return (m_it.primitive_iterator == other.m_it.primitive_iterator); + } + } + + /*! + @brief comparison: not equal + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + template < typename IterImpl, detail::enable_if_t < (std::is_same::value || std::is_same::value), std::nullptr_t > = nullptr > + bool operator!=(const IterImpl& other) const + { + return !operator==(other); + } + + /*! + @brief comparison: smaller + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + bool operator<(const iter_impl& other) const + { + // if objects are not the same, the comparison is undefined + if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) + { + JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object)); + } + + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object)); + + case value_t::array: + return (m_it.array_iterator < other.m_it.array_iterator); + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + return (m_it.primitive_iterator < other.m_it.primitive_iterator); + } + } + + /*! + @brief comparison: less than or equal + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + bool operator<=(const iter_impl& other) const + { + return !other.operator < (*this); + } + + /*! + @brief comparison: greater than + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + bool operator>(const iter_impl& other) const + { + return !operator<=(other); + } + + /*! + @brief comparison: greater than or equal + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + bool operator>=(const iter_impl& other) const + { + return !operator<(other); + } + + /*! + @brief add to iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl& operator+=(difference_type i) + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object)); + + case value_t::array: + { + std::advance(m_it.array_iterator, i); + break; + } + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + m_it.primitive_iterator += i; + break; + } + } + + return *this; + } + + /*! + @brief subtract from iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl& operator-=(difference_type i) + { + return operator+=(-i); + } + + /*! + @brief add to iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl operator+(difference_type i) const + { + auto result = *this; + result += i; + return result; + } + + /*! + @brief addition of distance and iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + friend iter_impl operator+(difference_type i, const iter_impl& it) + { + auto result = it; + result += i; + return result; + } + + /*! + @brief subtract from iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl operator-(difference_type i) const + { + auto result = *this; + result -= i; + return result; + } + + /*! + @brief return difference + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + difference_type operator-(const iter_impl& other) const + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object)); + + case value_t::array: + return m_it.array_iterator - other.m_it.array_iterator; + + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + return m_it.primitive_iterator - other.m_it.primitive_iterator; + } + } + + /*! + @brief access to successor + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + reference operator[](difference_type n) const + { + JSON_ASSERT(m_object != nullptr); + + switch (m_object->m_data.m_type) + { + case value_t::object: + JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object)); + + case value_t::array: + return *std::next(m_it.array_iterator, n); + + case value_t::null: + JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); + + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + { + if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n)) + { + return *m_object; + } + + JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); + } + } + } + + /*! + @brief return the key of an object iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + const typename object_t::key_type& key() const + { + JSON_ASSERT(m_object != nullptr); + + if (JSON_HEDLEY_LIKELY(m_object->is_object())) + { + return m_it.object_iterator->first; + } + + JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object)); + } + + /*! + @brief return the value of an iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + reference value() const + { + return operator*(); + } + + JSON_PRIVATE_UNLESS_TESTED: + /// associated JSON instance + pointer m_object = nullptr; + /// the actual iterator of the associated instance + internal_iterator::type> m_it {}; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iteration_proxy.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iteration_proxy.hpp new file mode 100644 index 0000000..76293de --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iteration_proxy.hpp @@ -0,0 +1,242 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // size_t +#include // input_iterator_tag +#include // string, to_string +#include // tuple_size, get, tuple_element +#include // move + +#if JSON_HAS_RANGES + #include // enable_borrowed_range +#endif + +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +void int_to_string( string_type& target, std::size_t value ) +{ + // For ADL + using std::to_string; + target = to_string(value); +} +template class iteration_proxy_value +{ + public: + using difference_type = std::ptrdiff_t; + using value_type = iteration_proxy_value; + using pointer = value_type *; + using reference = value_type &; + using iterator_category = std::input_iterator_tag; + using string_type = typename std::remove_cv< typename std::remove_reference().key() ) >::type >::type; + + private: + /// the iterator + IteratorType anchor{}; + /// an index for arrays (used to create key names) + std::size_t array_index = 0; + /// last stringified array index + mutable std::size_t array_index_last = 0; + /// a string representation of the array index + mutable string_type array_index_str = "0"; + /// an empty string (to return a reference for primitive values) + string_type empty_str{}; + + public: + explicit iteration_proxy_value() = default; + explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0) + noexcept(std::is_nothrow_move_constructible::value + && std::is_nothrow_default_constructible::value) + : anchor(std::move(it)) + , array_index(array_index_) + {} + + iteration_proxy_value(iteration_proxy_value const&) = default; + iteration_proxy_value& operator=(iteration_proxy_value const&) = default; + // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions + iteration_proxy_value(iteration_proxy_value&&) + noexcept(std::is_nothrow_move_constructible::value + && std::is_nothrow_move_constructible::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations) + iteration_proxy_value& operator=(iteration_proxy_value&&) + noexcept(std::is_nothrow_move_assignable::value + && std::is_nothrow_move_assignable::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations) + ~iteration_proxy_value() = default; + + /// dereference operator (needed for range-based for) + const iteration_proxy_value& operator*() const + { + return *this; + } + + /// increment operator (needed for range-based for) + iteration_proxy_value& operator++() + { + ++anchor; + ++array_index; + + return *this; + } + + iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp) + { + auto tmp = iteration_proxy_value(anchor, array_index); + ++anchor; + ++array_index; + return tmp; + } + + /// equality operator (needed for InputIterator) + bool operator==(const iteration_proxy_value& o) const + { + return anchor == o.anchor; + } + + /// inequality operator (needed for range-based for) + bool operator!=(const iteration_proxy_value& o) const + { + return anchor != o.anchor; + } + + /// return key of the iterator + const string_type& key() const + { + JSON_ASSERT(anchor.m_object != nullptr); + + switch (anchor.m_object->type()) + { + // use integer array index as key + case value_t::array: + { + if (array_index != array_index_last) + { + int_to_string( array_index_str, array_index ); + array_index_last = array_index; + } + return array_index_str; + } + + // use key from the object + case value_t::object: + return anchor.key(); + + // use an empty key for all primitive types + case value_t::null: + case value_t::string: + case value_t::boolean: + case value_t::number_integer: + case value_t::number_unsigned: + case value_t::number_float: + case value_t::binary: + case value_t::discarded: + default: + return empty_str; + } + } + + /// return value of the iterator + typename IteratorType::reference value() const + { + return anchor.value(); + } +}; + +/// proxy class for the items() function +template class iteration_proxy +{ + private: + /// the container to iterate + typename IteratorType::pointer container = nullptr; + + public: + explicit iteration_proxy() = default; + + /// construct iteration proxy from a container + explicit iteration_proxy(typename IteratorType::reference cont) noexcept + : container(&cont) {} + + iteration_proxy(iteration_proxy const&) = default; + iteration_proxy& operator=(iteration_proxy const&) = default; + iteration_proxy(iteration_proxy&&) noexcept = default; + iteration_proxy& operator=(iteration_proxy&&) noexcept = default; + ~iteration_proxy() = default; + + /// return iterator begin (needed for range-based for) + iteration_proxy_value begin() const noexcept + { + return iteration_proxy_value(container->begin()); + } + + /// return iterator end (needed for range-based for) + iteration_proxy_value end() const noexcept + { + return iteration_proxy_value(container->end()); + } +}; + +// Structured Bindings Support +// For further reference see https://blog.tartanllama.xyz/structured-bindings/ +// And see https://github.com/nlohmann/json/pull/1391 +template = 0> +auto get(const nlohmann::detail::iteration_proxy_value& i) -> decltype(i.key()) +{ + return i.key(); +} +// Structured Bindings Support +// For further reference see https://blog.tartanllama.xyz/structured-bindings/ +// And see https://github.com/nlohmann/json/pull/1391 +template = 0> +auto get(const nlohmann::detail::iteration_proxy_value& i) -> decltype(i.value()) +{ + return i.value(); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// The Addition to the STD Namespace is required to add +// Structured Bindings Support to the iteration_proxy_value class +// For further reference see https://blog.tartanllama.xyz/structured-bindings/ +// And see https://github.com/nlohmann/json/pull/1391 +namespace std +{ + +#if defined(__clang__) + // Fix: https://github.com/nlohmann/json/issues/1401 + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wmismatched-tags" +#endif +template +class tuple_size<::nlohmann::detail::iteration_proxy_value> // NOLINT(cert-dcl58-cpp) + : public std::integral_constant {}; + +template +class tuple_element> // NOLINT(cert-dcl58-cpp) +{ + public: + using type = decltype( + get(std::declval < + ::nlohmann::detail::iteration_proxy_value> ())); +}; +#if defined(__clang__) + #pragma clang diagnostic pop +#endif + +} // namespace std + +#if JSON_HAS_RANGES + template + inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy> = true; +#endif diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iterator_traits.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iterator_traits.hpp new file mode 100644 index 0000000..84cc27a --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/iterator_traits.hpp @@ -0,0 +1,61 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // random_access_iterator_tag + +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/json_reverse_iterator.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/json_reverse_iterator.hpp new file mode 100644 index 0000000..006d549 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/json_reverse_iterator.hpp @@ -0,0 +1,130 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // ptrdiff_t +#include // reverse_iterator +#include // declval + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +////////////////////// +// reverse_iterator // +////////////////////// + +/*! +@brief a template for a reverse iterator class + +@tparam Base the base iterator type to reverse. Valid types are @ref +iterator (to create @ref reverse_iterator) and @ref const_iterator (to +create @ref const_reverse_iterator). + +@requirement The class satisfies the following concept requirements: +- +[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator): + The iterator that can be moved can be moved in both directions (i.e. + incremented and decremented). +- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator): + It is possible to write to the pointed-to element (only if @a Base is + @ref iterator). + +@since version 1.0.0 +*/ +template +class json_reverse_iterator : public std::reverse_iterator +{ + public: + using difference_type = std::ptrdiff_t; + /// shortcut to the reverse iterator adapter + using base_iterator = std::reverse_iterator; + /// the reference type for the pointed-to element + using reference = typename Base::reference; + + /// create reverse iterator from iterator + explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept + : base_iterator(it) {} + + /// create reverse iterator from base class + explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {} + + /// post-increment (it++) + json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp) + { + return static_cast(base_iterator::operator++(1)); + } + + /// pre-increment (++it) + json_reverse_iterator& operator++() + { + return static_cast(base_iterator::operator++()); + } + + /// post-decrement (it--) + json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp) + { + return static_cast(base_iterator::operator--(1)); + } + + /// pre-decrement (--it) + json_reverse_iterator& operator--() + { + return static_cast(base_iterator::operator--()); + } + + /// add to iterator + json_reverse_iterator& operator+=(difference_type i) + { + return static_cast(base_iterator::operator+=(i)); + } + + /// add to iterator + json_reverse_iterator operator+(difference_type i) const + { + return static_cast(base_iterator::operator+(i)); + } + + /// subtract from iterator + json_reverse_iterator operator-(difference_type i) const + { + return static_cast(base_iterator::operator-(i)); + } + + /// return difference + difference_type operator-(const json_reverse_iterator& other) const + { + return base_iterator(*this) - base_iterator(other); + } + + /// access to successor + reference operator[](difference_type n) const + { + return *(this->operator+(n)); + } + + /// return the key of an object iterator + auto key() const -> decltype(std::declval().key()) + { + auto it = --this->base(); + return it.key(); + } + + /// return the value of an iterator + reference value() const + { + auto it = --this->base(); + return it.operator * (); + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/primitive_iterator.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/primitive_iterator.hpp new file mode 100644 index 0000000..0b6e849 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/iterators/primitive_iterator.hpp @@ -0,0 +1,132 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // ptrdiff_t +#include // numeric_limits + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/* +@brief an iterator for primitive JSON types + +This class models an iterator for primitive JSON types (boolean, number, +string). It's only purpose is to allow the iterator/const_iterator classes +to "iterate" over primitive values. Internally, the iterator is modeled by +a `difference_type` variable. Value begin_value (`0`) models the begin, +end_value (`1`) models past the end. +*/ +class primitive_iterator_t +{ + private: + using difference_type = std::ptrdiff_t; + static constexpr difference_type begin_value = 0; + static constexpr difference_type end_value = begin_value + 1; + + JSON_PRIVATE_UNLESS_TESTED: + /// iterator as signed integer type + difference_type m_it = (std::numeric_limits::min)(); + + public: + constexpr difference_type get_value() const noexcept + { + return m_it; + } + + /// set iterator to a defined beginning + void set_begin() noexcept + { + m_it = begin_value; + } + + /// set iterator to a defined past the end + void set_end() noexcept + { + m_it = end_value; + } + + /// return whether the iterator can be dereferenced + constexpr bool is_begin() const noexcept + { + return m_it == begin_value; + } + + /// return whether the iterator is at end + constexpr bool is_end() const noexcept + { + return m_it == end_value; + } + + friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept + { + return lhs.m_it == rhs.m_it; + } + + friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept + { + return lhs.m_it < rhs.m_it; + } + + primitive_iterator_t operator+(difference_type n) noexcept + { + auto result = *this; + result += n; + return result; + } + + friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept + { + return lhs.m_it - rhs.m_it; + } + + primitive_iterator_t& operator++() noexcept + { + ++m_it; + return *this; + } + + primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp) + { + auto result = *this; + ++m_it; + return result; + } + + primitive_iterator_t& operator--() noexcept + { + --m_it; + return *this; + } + + primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp) + { + auto result = *this; + --m_it; + return result; + } + + primitive_iterator_t& operator+=(difference_type n) noexcept + { + m_it += n; + return *this; + } + + primitive_iterator_t& operator-=(difference_type n) noexcept + { + m_it -= n; + return *this; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_custom_base_class.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_custom_base_class.hpp new file mode 100644 index 0000000..d1e2916 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_custom_base_class.hpp @@ -0,0 +1,39 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // conditional, is_same + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief Default base class of the @ref basic_json class. + +So that the correct implementations of the copy / move ctors / assign operators +of @ref basic_json do not require complex case distinctions +(no base class / custom base class used as customization point), +@ref basic_json always has a base class. +By default, this class is used because it is empty and thus has no effect +on the behavior of @ref basic_json. +*/ +struct json_default_base {}; + +template +using json_base_class = typename std::conditional < + std::is_same::value, + json_default_base, + T + >::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_pointer.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_pointer.hpp new file mode 100644 index 0000000..4fdcd9a --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_pointer.hpp @@ -0,0 +1,988 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // all_of +#include // isdigit +#include // errno, ERANGE +#include // strtoull +#ifndef JSON_NO_IO + #include // ostream +#endif // JSON_NO_IO +#include // max +#include // accumulate +#include // string +#include // move +#include // vector + +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN + +/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document +/// @sa https://json.nlohmann.me/api/json_pointer/ +template +class json_pointer +{ + // allow basic_json to access private members + NLOHMANN_BASIC_JSON_TPL_DECLARATION + friend class basic_json; + + template + friend class json_pointer; + + template + struct string_t_helper + { + using type = T; + }; + + NLOHMANN_BASIC_JSON_TPL_DECLARATION + struct string_t_helper + { + using type = StringType; + }; + + public: + // for backwards compatibility accept BasicJsonType + using string_t = typename string_t_helper::type; + + /// @brief create JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/ + explicit json_pointer(const string_t& s = "") + : reference_tokens(split(s)) + {} + + /// @brief return a string representation of the JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/to_string/ + string_t to_string() const + { + return std::accumulate(reference_tokens.begin(), reference_tokens.end(), + string_t{}, + [](const string_t& a, const string_t& b) + { + return detail::concat(a, '/', detail::escape(b)); + }); + } + + /// @brief return a string representation of the JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/ + JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string()) + operator string_t() const + { + return to_string(); + } + +#ifndef JSON_NO_IO + /// @brief write string representation of the JSON pointer to stream + /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/ + friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr) + { + o << ptr.to_string(); + return o; + } +#endif + + /// @brief append another JSON pointer at the end of this JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/ + json_pointer& operator/=(const json_pointer& ptr) + { + reference_tokens.insert(reference_tokens.end(), + ptr.reference_tokens.begin(), + ptr.reference_tokens.end()); + return *this; + } + + /// @brief append an unescaped reference token at the end of this JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/ + json_pointer& operator/=(string_t token) + { + push_back(std::move(token)); + return *this; + } + + /// @brief append an array index at the end of this JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/ + json_pointer& operator/=(std::size_t array_idx) + { + return *this /= std::to_string(array_idx); + } + + /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/ + friend json_pointer operator/(const json_pointer& lhs, + const json_pointer& rhs) + { + return json_pointer(lhs) /= rhs; + } + + /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/ + friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param) + { + return json_pointer(lhs) /= std::move(token); + } + + /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/ + friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx) + { + return json_pointer(lhs) /= array_idx; + } + + /// @brief returns the parent of this JSON pointer + /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/ + json_pointer parent_pointer() const + { + if (empty()) + { + return *this; + } + + json_pointer res = *this; + res.pop_back(); + return res; + } + + /// @brief remove last reference token + /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/ + void pop_back() + { + if (JSON_HEDLEY_UNLIKELY(empty())) + { + JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr)); + } + + reference_tokens.pop_back(); + } + + /// @brief return last reference token + /// @sa https://json.nlohmann.me/api/json_pointer/back/ + const string_t& back() const + { + if (JSON_HEDLEY_UNLIKELY(empty())) + { + JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr)); + } + + return reference_tokens.back(); + } + + /// @brief append an unescaped token at the end of the reference pointer + /// @sa https://json.nlohmann.me/api/json_pointer/push_back/ + void push_back(const string_t& token) + { + reference_tokens.push_back(token); + } + + /// @brief append an unescaped token at the end of the reference pointer + /// @sa https://json.nlohmann.me/api/json_pointer/push_back/ + void push_back(string_t&& token) + { + reference_tokens.push_back(std::move(token)); + } + + /// @brief return whether pointer points to the root document + /// @sa https://json.nlohmann.me/api/json_pointer/empty/ + bool empty() const noexcept + { + return reference_tokens.empty(); + } + + private: + /*! + @param[in] s reference token to be converted into an array index + + @return integer representation of @a s + + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index begins not with a digit + @throw out_of_range.404 if string @a s could not be converted to an integer + @throw out_of_range.410 if an array index exceeds size_type + */ + template + static typename BasicJsonType::size_type array_index(const string_t& s) + { + using size_type = typename BasicJsonType::size_type; + + // error condition (cf. RFC 6901, Sect. 4) + if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0')) + { + JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr)); + } + + // error condition (cf. RFC 6901, Sect. 4) + if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9'))) + { + JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr)); + } + + const char* p = s.c_str(); + char* p_end = nullptr; + errno = 0; // strtoull doesn't reset errno + const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int) + if (p == p_end // invalid input or empty string + || errno == ERANGE // out of range + || JSON_HEDLEY_UNLIKELY(static_cast(p_end - p) != s.size())) // incomplete read + { + JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr)); + } + + // only triggered on special platforms (like 32bit), see also + // https://github.com/nlohmann/json/pull/2203 + if (res >= static_cast((std::numeric_limits::max)())) // NOLINT(runtime/int) + { + JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr)); // LCOV_EXCL_LINE + } + + return static_cast(res); + } + + JSON_PRIVATE_UNLESS_TESTED: + json_pointer top() const + { + if (JSON_HEDLEY_UNLIKELY(empty())) + { + JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr)); + } + + json_pointer result = *this; + result.reference_tokens = {reference_tokens[0]}; + return result; + } + + private: + /*! + @brief create and return a reference to the pointed to value + + @complexity Linear in the number of reference tokens. + + @throw parse_error.109 if array index is not a number + @throw type_error.313 if value cannot be unflattened + */ + template + BasicJsonType& get_and_create(BasicJsonType& j) const + { + auto* result = &j; + + // in case no reference tokens exist, return a reference to the JSON value + // j which will be overwritten by a primitive value + for (const auto& reference_token : reference_tokens) + { + switch (result->type()) + { + case detail::value_t::null: + { + if (reference_token == "0") + { + // start a new array if reference token is 0 + result = &result->operator[](0); + } + else + { + // start a new object otherwise + result = &result->operator[](reference_token); + } + break; + } + + case detail::value_t::object: + { + // create an entry in the object + result = &result->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + // create an entry in the array + result = &result->operator[](array_index(reference_token)); + break; + } + + /* + The following code is only reached if there exists a reference + token _and_ the current value is primitive. In this case, we have + an error situation, because primitive values may only occur as + single value; that is, with an empty list of reference tokens. + */ + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j)); + } + } + + return *result; + } + + /*! + @brief return a reference to the pointed to value + + @note This version does not throw if a value is not present, but tries to + create nested values instead. For instance, calling this function + with pointer `"/this/that"` on a null value is equivalent to calling + `operator[]("this").operator[]("that")` on that value, effectively + changing the null value to an object. + + @param[in] ptr a JSON value + + @return reference to the JSON value pointed to by the JSON pointer + + @complexity Linear in the length of the JSON pointer. + + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + template + BasicJsonType& get_unchecked(BasicJsonType* ptr) const + { + for (const auto& reference_token : reference_tokens) + { + // convert null values to arrays or objects before continuing + if (ptr->is_null()) + { + // check if reference token is a number + const bool nums = + std::all_of(reference_token.begin(), reference_token.end(), + [](const unsigned char x) + { + return std::isdigit(x); + }); + + // change value to array for numbers or "-" or to object otherwise + *ptr = (nums || reference_token == "-") + ? detail::value_t::array + : detail::value_t::object; + } + + switch (ptr->type()) + { + case detail::value_t::object: + { + // use unchecked object access + ptr = &ptr->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + if (reference_token == "-") + { + // explicitly treat "-" as index beyond the end + ptr = &ptr->operator[](ptr->m_data.m_value.array->size()); + } + else + { + // convert array index to number; unchecked access + ptr = &ptr->operator[](array_index(reference_token)); + } + break; + } + + case detail::value_t::null: + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); + } + } + + return *ptr; + } + + /*! + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + template + BasicJsonType& get_checked(BasicJsonType* ptr) const + { + for (const auto& reference_token : reference_tokens) + { + switch (ptr->type()) + { + case detail::value_t::object: + { + // note: at performs range check + ptr = &ptr->at(reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) + { + // "-" always fails the range check + JSON_THROW(detail::out_of_range::create(402, detail::concat( + "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), + ") is out of range"), ptr)); + } + + // note: at performs range check + ptr = &ptr->at(array_index(reference_token)); + break; + } + + case detail::value_t::null: + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); + } + } + + return *ptr; + } + + /*! + @brief return a const reference to the pointed to value + + @param[in] ptr a JSON value + + @return const reference to the JSON value pointed to by the JSON + pointer + + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + template + const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const + { + for (const auto& reference_token : reference_tokens) + { + switch (ptr->type()) + { + case detail::value_t::object: + { + // use unchecked object access + ptr = &ptr->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) + { + // "-" cannot be used for const access + JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr)); + } + + // use unchecked array access + ptr = &ptr->operator[](array_index(reference_token)); + break; + } + + case detail::value_t::null: + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); + } + } + + return *ptr; + } + + /*! + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + template + const BasicJsonType& get_checked(const BasicJsonType* ptr) const + { + for (const auto& reference_token : reference_tokens) + { + switch (ptr->type()) + { + case detail::value_t::object: + { + // note: at performs range check + ptr = &ptr->at(reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) + { + // "-" always fails the range check + JSON_THROW(detail::out_of_range::create(402, detail::concat( + "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), + ") is out of range"), ptr)); + } + + // note: at performs range check + ptr = &ptr->at(array_index(reference_token)); + break; + } + + case detail::value_t::null: + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); + } + } + + return *ptr; + } + + /*! + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + */ + template + bool contains(const BasicJsonType* ptr) const + { + for (const auto& reference_token : reference_tokens) + { + switch (ptr->type()) + { + case detail::value_t::object: + { + if (!ptr->contains(reference_token)) + { + // we did not find the key in the object + return false; + } + + ptr = &ptr->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) + { + // "-" always fails the range check + return false; + } + if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9"))) + { + // invalid char + return false; + } + if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1)) + { + if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9'))) + { + // first char should be between '1' and '9' + return false; + } + for (std::size_t i = 1; i < reference_token.size(); i++) + { + if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9'))) + { + // other char should be between '0' and '9' + return false; + } + } + } + + const auto idx = array_index(reference_token); + if (idx >= ptr->size()) + { + // index out of range + return false; + } + + ptr = &ptr->operator[](idx); + break; + } + + case detail::value_t::null: + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + { + // we do not expect primitive values if there is still a + // reference token to process + return false; + } + } + } + + // no reference token left means we found a primitive value + return true; + } + + /*! + @brief split the string input to reference tokens + + @note This function is only called by the json_pointer constructor. + All exceptions below are documented there. + + @throw parse_error.107 if the pointer is not empty or begins with '/' + @throw parse_error.108 if character '~' is not followed by '0' or '1' + */ + static std::vector split(const string_t& reference_string) + { + std::vector result; + + // special case: empty reference string -> no reference tokens + if (reference_string.empty()) + { + return result; + } + + // check if nonempty reference string begins with slash + if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/')) + { + JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr)); + } + + // extract the reference tokens: + // - slash: position of the last read slash (or end of string) + // - start: position after the previous slash + for ( + // search for the first slash after the first character + std::size_t slash = reference_string.find_first_of('/', 1), + // set the beginning of the first reference token + start = 1; + // we can stop if start == 0 (if slash == string_t::npos) + start != 0; + // set the beginning of the next reference token + // (will eventually be 0 if slash == string_t::npos) + start = (slash == string_t::npos) ? 0 : slash + 1, + // find next slash + slash = reference_string.find_first_of('/', start)) + { + // use the text between the beginning of the reference token + // (start) and the last slash (slash). + auto reference_token = reference_string.substr(start, slash - start); + + // check reference tokens are properly escaped + for (std::size_t pos = reference_token.find_first_of('~'); + pos != string_t::npos; + pos = reference_token.find_first_of('~', pos + 1)) + { + JSON_ASSERT(reference_token[pos] == '~'); + + // ~ must be followed by 0 or 1 + if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 || + (reference_token[pos + 1] != '0' && + reference_token[pos + 1] != '1'))) + { + JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr)); + } + } + + // finally, store the reference token + detail::unescape(reference_token); + result.push_back(reference_token); + } + + return result; + } + + private: + /*! + @param[in] reference_string the reference string to the current value + @param[in] value the value to consider + @param[in,out] result the result object to insert values to + + @note Empty objects or arrays are flattened to `null`. + */ + template + static void flatten(const string_t& reference_string, + const BasicJsonType& value, + BasicJsonType& result) + { + switch (value.type()) + { + case detail::value_t::array: + { + if (value.m_data.m_value.array->empty()) + { + // flatten empty array as null + result[reference_string] = nullptr; + } + else + { + // iterate array and use index as reference string + for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i) + { + flatten(detail::concat(reference_string, '/', std::to_string(i)), + value.m_data.m_value.array->operator[](i), result); + } + } + break; + } + + case detail::value_t::object: + { + if (value.m_data.m_value.object->empty()) + { + // flatten empty object as null + result[reference_string] = nullptr; + } + else + { + // iterate object and use keys as reference string + for (const auto& element : *value.m_data.m_value.object) + { + flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result); + } + } + break; + } + + case detail::value_t::null: + case detail::value_t::string: + case detail::value_t::boolean: + case detail::value_t::number_integer: + case detail::value_t::number_unsigned: + case detail::value_t::number_float: + case detail::value_t::binary: + case detail::value_t::discarded: + default: + { + // add primitive value with its reference string + result[reference_string] = value; + break; + } + } + } + + /*! + @param[in] value flattened JSON + + @return unflattened JSON + + @throw parse_error.109 if array index is not a number + @throw type_error.314 if value is not an object + @throw type_error.315 if object values are not primitive + @throw type_error.313 if value cannot be unflattened + */ + template + static BasicJsonType + unflatten(const BasicJsonType& value) + { + if (JSON_HEDLEY_UNLIKELY(!value.is_object())) + { + JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value)); + } + + BasicJsonType result; + + // iterate the JSON object values + for (const auto& element : *value.m_data.m_value.object) + { + if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive())) + { + JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second)); + } + + // assign value to reference pointed to by JSON pointer; Note that if + // the JSON pointer is "" (i.e., points to the whole value), function + // get_and_create returns a reference to result itself. An assignment + // will then create a primitive value. + json_pointer(element.first).get_and_create(result) = element.second; + } + + return result; + } + + // can't use conversion operator because of ambiguity + json_pointer convert() const& + { + json_pointer result; + result.reference_tokens = reference_tokens; + return result; + } + + json_pointer convert()&& + { + json_pointer result; + result.reference_tokens = std::move(reference_tokens); + return result; + } + + public: +#if JSON_HAS_THREE_WAY_COMPARISON + /// @brief compares two JSON pointers for equality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ + template + bool operator==(const json_pointer& rhs) const noexcept + { + return reference_tokens == rhs.reference_tokens; + } + + /// @brief compares JSON pointer and string for equality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ + JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer)) + bool operator==(const string_t& rhs) const + { + return *this == json_pointer(rhs); + } + + /// @brief 3-way compares two JSON pointers + template + std::strong_ordering operator<=>(const json_pointer& rhs) const noexcept // *NOPAD* + { + return reference_tokens <=> rhs.reference_tokens; // *NOPAD* + } +#else + /// @brief compares two JSON pointers for equality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator==(const json_pointer& lhs, + const json_pointer& rhs) noexcept; + + /// @brief compares JSON pointer and string for equality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator==(const json_pointer& lhs, + const StringType& rhs); + + /// @brief compares string and JSON pointer for equality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator==(const StringType& lhs, + const json_pointer& rhs); + + /// @brief compares two JSON pointers for inequality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/ + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator!=(const json_pointer& lhs, + const json_pointer& rhs) noexcept; + + /// @brief compares JSON pointer and string for inequality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/ + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator!=(const json_pointer& lhs, + const StringType& rhs); + + /// @brief compares string and JSON pointer for inequality + /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/ + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator!=(const StringType& lhs, + const json_pointer& rhs); + + /// @brief compares two JSON pointer for less-than + template + // NOLINTNEXTLINE(readability-redundant-declaration) + friend bool operator<(const json_pointer& lhs, + const json_pointer& rhs) noexcept; +#endif + + private: + /// the reference tokens + std::vector reference_tokens; +}; + +#if !JSON_HAS_THREE_WAY_COMPARISON +// functions cannot be defined inside class due to ODR violations +template +inline bool operator==(const json_pointer& lhs, + const json_pointer& rhs) noexcept +{ + return lhs.reference_tokens == rhs.reference_tokens; +} + +template::string_t> +JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) +inline bool operator==(const json_pointer& lhs, + const StringType& rhs) +{ + return lhs == json_pointer(rhs); +} + +template::string_t> +JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) +inline bool operator==(const StringType& lhs, + const json_pointer& rhs) +{ + return json_pointer(lhs) == rhs; +} + +template +inline bool operator!=(const json_pointer& lhs, + const json_pointer& rhs) noexcept +{ + return !(lhs == rhs); +} + +template::string_t> +JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) +inline bool operator!=(const json_pointer& lhs, + const StringType& rhs) +{ + return !(lhs == rhs); +} + +template::string_t> +JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) +inline bool operator!=(const StringType& lhs, + const json_pointer& rhs) +{ + return !(lhs == rhs); +} + +template +inline bool operator<(const json_pointer& lhs, + const json_pointer& rhs) noexcept +{ + return lhs.reference_tokens < rhs.reference_tokens; +} +#endif + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_ref.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_ref.hpp new file mode 100644 index 0000000..b8bb6a7 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/json_ref.hpp @@ -0,0 +1,78 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include +#include + +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +class json_ref +{ + public: + using value_type = BasicJsonType; + + json_ref(value_type&& value) + : owned_value(std::move(value)) + {} + + json_ref(const value_type& value) + : value_ref(&value) + {} + + json_ref(std::initializer_list init) + : owned_value(init) + {} + + template < + class... Args, + enable_if_t::value, int> = 0 > + json_ref(Args && ... args) + : owned_value(std::forward(args)...) + {} + + // class should be movable only + json_ref(json_ref&&) noexcept = default; + json_ref(const json_ref&) = delete; + json_ref& operator=(const json_ref&) = delete; + json_ref& operator=(json_ref&&) = delete; + ~json_ref() = default; + + value_type moved_or_copied() const + { + if (value_ref == nullptr) + { + return std::move(owned_value); + } + return *value_ref; + } + + value_type const& operator*() const + { + return value_ref ? *value_ref : owned_value; + } + + value_type const* operator->() const + { + return &** this; + } + + private: + mutable value_type owned_value = nullptr; + value_type const* value_ref = nullptr; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_scope.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_scope.hpp new file mode 100644 index 0000000..97127a6 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_scope.hpp @@ -0,0 +1,482 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // declval, pair +#include +#include + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +#include + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1); + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows to call any std function as if (e.g. with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_unscope.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_unscope.hpp new file mode 100644 index 0000000..c6620d1 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/macro_unscope.hpp @@ -0,0 +1,45 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +// restore clang diagnostic settings +#if defined(__clang__) + #pragma clang diagnostic pop +#endif + +// clean up +#undef JSON_ASSERT +#undef JSON_INTERNAL_CATCH +#undef JSON_THROW +#undef JSON_PRIVATE_UNLESS_TESTED +#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION +#undef NLOHMANN_BASIC_JSON_TPL +#undef JSON_EXPLICIT +#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL +#undef JSON_INLINE_VARIABLE +#undef JSON_NO_UNIQUE_ADDRESS +#undef JSON_DISABLE_ENUM_SERIALIZATION +#undef JSON_USE_GLOBAL_UDLS + +#ifndef JSON_TEST_KEEP_MACROS + #undef JSON_CATCH + #undef JSON_TRY + #undef JSON_HAS_CPP_11 + #undef JSON_HAS_CPP_14 + #undef JSON_HAS_CPP_17 + #undef JSON_HAS_CPP_20 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #undef JSON_HAS_THREE_WAY_COMPARISON + #undef JSON_HAS_RANGES + #undef JSON_HAS_STATIC_RTTI + #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#include diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/begin.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/begin.hpp new file mode 100644 index 0000000..364cc89 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/begin.hpp @@ -0,0 +1,17 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/end.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/end.hpp new file mode 100644 index 0000000..463f070 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/call_std/end.hpp @@ -0,0 +1,17 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/cpp_future.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/cpp_future.hpp new file mode 100644 index 0000000..412b5aa --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/cpp_future.hpp @@ -0,0 +1,171 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + +#pragma once + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +inline constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/detected.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/detected.hpp new file mode 100644 index 0000000..1db9bf9 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/detected.hpp @@ -0,0 +1,70 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/identity_tag.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/identity_tag.hpp new file mode 100644 index 0000000..269deff --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/identity_tag.hpp @@ -0,0 +1,21 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// dispatching helper struct +template struct identity_tag {}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/is_sax.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/is_sax.hpp new file mode 100644 index 0000000..4e02bc1 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/is_sax.hpp @@ -0,0 +1,159 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // size_t +#include // declval +#include // string + +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using null_function_t = decltype(std::declval().null()); + +template +using boolean_function_t = + decltype(std::declval().boolean(std::declval())); + +template +using number_integer_function_t = + decltype(std::declval().number_integer(std::declval())); + +template +using number_unsigned_function_t = + decltype(std::declval().number_unsigned(std::declval())); + +template +using number_float_function_t = decltype(std::declval().number_float( + std::declval(), std::declval())); + +template +using string_function_t = + decltype(std::declval().string(std::declval())); + +template +using binary_function_t = + decltype(std::declval().binary(std::declval())); + +template +using start_object_function_t = + decltype(std::declval().start_object(std::declval())); + +template +using key_function_t = + decltype(std::declval().key(std::declval())); + +template +using end_object_function_t = decltype(std::declval().end_object()); + +template +using start_array_function_t = + decltype(std::declval().start_array(std::declval())); + +template +using end_array_function_t = decltype(std::declval().end_array()); + +template +using parse_error_function_t = decltype(std::declval().parse_error( + std::declval(), std::declval(), + std::declval())); + +template +struct is_sax +{ + private: + static_assert(is_basic_json::value, + "BasicJsonType must be of type basic_json<...>"); + + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + using exception_t = typename BasicJsonType::exception; + + public: + static constexpr bool value = + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value && + is_detected_exact::value; +}; + +template +struct is_sax_static_asserts +{ + private: + static_assert(is_basic_json::value, + "BasicJsonType must be of type basic_json<...>"); + + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using string_t = typename BasicJsonType::string_t; + using binary_t = typename BasicJsonType::binary_t; + using exception_t = typename BasicJsonType::exception; + + public: + static_assert(is_detected_exact::value, + "Missing/invalid function: bool null()"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool boolean(bool)"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool boolean(bool)"); + static_assert( + is_detected_exact::value, + "Missing/invalid function: bool number_integer(number_integer_t)"); + static_assert( + is_detected_exact::value, + "Missing/invalid function: bool number_unsigned(number_unsigned_t)"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool number_float(number_float_t, const string_t&)"); + static_assert( + is_detected_exact::value, + "Missing/invalid function: bool string(string_t&)"); + static_assert( + is_detected_exact::value, + "Missing/invalid function: bool binary(binary_t&)"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool start_object(std::size_t)"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool key(string_t&)"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool end_object()"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool start_array(std::size_t)"); + static_assert(is_detected_exact::value, + "Missing/invalid function: bool end_array()"); + static_assert( + is_detected_exact::value, + "Missing/invalid function: bool parse_error(std::size_t, const " + "std::string&, const exception&)"); +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/std_fs.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/std_fs.hpp new file mode 100644 index 0000000..fd18039 --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/std_fs.hpp @@ -0,0 +1,29 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include + +#if JSON_HAS_EXPERIMENTAL_FILESYSTEM +#include +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ +namespace std_fs = std::experimental::filesystem; +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END +#elif JSON_HAS_FILESYSTEM +#include +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ +namespace std_fs = std::filesystem; +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END +#endif diff --git a/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/type_traits.hpp b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/type_traits.hpp new file mode 100644 index 0000000..e1b000d --- /dev/null +++ b/DatabaseGenerator/lib/All/jsonfmcpp/include/nlohmann/detail/meta/type_traits.hpp @@ -0,0 +1,795 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#pragma once + +#include // numeric_limits +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval +#include // tuple +#include // char_traits + +#include +#include +#include +#include +#include +#include +#include + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& + is_complete_type < + detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template