glaze

釉薬

世界最速の JSON ライブラリの 1 つ。 Glaze はオブジェクト メモリからの読み取りと書き込みを行い、インターフェイスを簡素化し、驚異的なパフォーマンスを提供します。

Glaze は以下もサポートしています。

• BEVE (バイナリの効率的な多用途エンコーディング)
• CSV (カンマ区切り値)

MSVC、Clang、GCC のコンパイル時反映機能付き!

• メタデータやマクロを書かずに、初期化可能な集合体構造体の読み取り/書き込みが可能です。
• Compiler Explorer の例を参照してください

ハイライト

• 構造体の純粋なコンパイル時リフレクション

  • カスタム名と動作のための強力なメタ特殊化システム

• JSON RFC 8259 への UTF-8 検証への準拠

• 標準 C++ ライブラリのサポート

• ヘッダーのみ

• メモリへの直接シリアル化/逆シリアル化

• 一定の時間ルックアップと完全なハッシュを使用してタイム マップをコンパイルする

• 読み取り/書き込み動作を変更する強力なラッパー (ラッパー)

• 独自のカスタム読み取り/書き込み関数を使用する (カスタム読み取り/書き込み)

• 不明なキーを迅速かつ柔軟に処理します

• JSON ポインター構文による直接メモリ アクセス

• 最大のパフォーマンスを実現する同じ API を介したバイナリ データ

• 例外なし ( -fno-exceptionsでコンパイル)

  • よりクリーンな構文をスローするヘルパーが必要な場合は、Glaze Exceptions を参照してください。

• 実行時の型情報は必要ありません ( -fno-rttiを使用してコンパイルします)

• 短絡による迅速なエラー処理

• JSON-RPC 2.0のサポート

• JSONスキーマの生成

• 非常に移植性が高く、慎重に最適化された SWAR (SIMD Within A Register) を使用して幅広い互換性を実現

• 部分読み取りおよび部分書き込みのサポート

• CSV読み込み/書き込み

• もっともっと！

詳細については、DOCS を参照してください。

パフォーマンス

図書館	往復時間 (秒)	書き込み (MB/秒)	読み取り (MB/秒)
釉薬	1.04	1366	1224
simdjson (オンデマンド)	該当なし	該当なし	1198
yyjson	1.23	1005	1107
daw_json_link	2.93	365	553
RapidJSON	3.65	290	450
Boost.JSON (直接)	4.76	199	447
json_struct	5.50	182	326
ンローマン	15.71	84	80

パフォーマンス テスト コードはここから入手できます

パフォーマンスに関する注意点: simdjson と yyjson は優れていますが、データが予期した順序にない場合やキーが欠落している場合は、大幅なパフォーマンスの低下が発生します (ドキュメント内で繰り返し処理する必要があるため、ファイル サイズが大きくなるにつれて問題は大きくなります)。

また、simdjson と yyjson はエスケープ文字列の自動処理をサポートしていないため、このベンチマークの現在エスケープされていない文字列のいずれかにエスケープが含まれている場合、エスケープは処理されません。

ABC テストは、キーが予期した順序にない場合に simdjson のパフォーマンスがどのように低下​​するかを示します。

図書館	読み取り (MB/秒)
釉薬	678
simdjson (オンデマンド)	93

バイナリパフォーマンス

タグ付きバイナリ仕様: BEVE

メトリック	往復時間 (秒)	書き込み (MB/秒)	読み取り (MB/秒)
生のパフォーマンス	0.42	3235	2468
同等の JSON データ*	0.42	3547	2706

JSONサイズ: 670バイト

BEVE サイズ: 611 バイト

*BEVE は JSON よりも効率的にパックするため、同じデータの転送がさらに高速になります。

例

構造体は自動的に反映されます。ユーザーがメタデータを必要とすることはありません。

 struct my_struct
{
  int i = 287 ;
  double d = 3.14 ;
  std::string hello = " Hello World " ;
  std::array< uint64_t , 3 > arr = { 1 , 2 , 3 };
  std::map<std::string, int > map{{ " one " , 1 }, { " two " , 2 }};
};

JSON (整形)

{
   "i" : 287 ,
   "d" : 3.14 ,
   "hello" : " Hello World " ,
   "arr" : [
      1 ,
      2 ,
      3
   ],
   "map" : {
      "one" : 1 ,
      "two" : 2
   }
}

JSONを書く

my_struct s{};
std::string buffer = glz::write_json(s).value_or( " error " );

または

my_struct s{};
std::string buffer{};
auto ec = glz::write_json(s, buffer);
if (ec) {
  // handle error
}

JSONを読む

std::string buffer = R"( {"i":287,"d":3.14,"hello":"Hello World","arr":[1,2,3],"map":{"one":1,"two":2}} )" ;
auto s = glz::read_json<my_struct>(buffer);
if (s) // check std::expected
{
  s. value (); // s.value() is a my_struct populated from buffer
}

または

std::string buffer = R"( {"i":287,"d":3.14,"hello":"Hello World","arr":[1,2,3],"map":{"one":1,"two":2}} )" ;
my_struct s{};
auto ec = glz::read_json(s, buffer); // populates s from buffer
if (ec) {
  // handle error
}

ファイルからの読み取り/書き込み

 auto ec = glz::read_file_json(obj, " ./obj.json " , std::string{});
auto ec = glz::write_file_json(obj, " ./obj.json " , std::string{});

重要

ファイル名 (2 番目の引数) は null で終了する必要があります。

コンパイラ/システムサポート

• C++23が必要です
• 64ビットと32ビットの両方でテスト済み
• リトルエンディアンシステムのみをサポートします

アクションは、Apple、Windows、Linux 上の Clang (17 以降)、MSVC (2022)、および GCC (12 以降) を使用してビルドおよびテストされます。

Glaze は、GCC および Clang の最新 3 バージョン、および MSVC および Apple Clang の最新バージョンとの互換性を維持することを目指しています。

MSVC コンパイラ フラグ

Glaze は C++ 標準に準拠したプリプロセッサを必要とし、MSVC でビルドする場合は/Zc:preprocessorフラグが必要です。

SIMD CMake オプション

CMake にはglaze_ENABLE_AVX2オプションがあります。これは、構成しているシステムが AVX2 SIMD 命令をサポートしている限り、パフォーマンスを向上させるために、場合によってはAVX2 SIMD 命令の使用を試みます。 Arm 用にクロスコンパイルしている場合など、AVX2 命令セットを無効にするには、このオプションをOFFに設定します。 CMake を使用していない場合は、マクロGLZ_USE_AVX2定義されていればこの機能を有効にします。

釉薬の使い方

コンテンツの取得

 include (FetchContent)

FetchContent_Declare(
  glaze
  GIT_REPOSITORY https://github.com/stephenberry/glaze.git
  GIT_TAG main
  GIT_SHALLOW TRUE
)

FetchContent_MakeAvailable(glaze)

target_link_libraries ( ${PROJECT_NAME} PRIVATE glaze::glaze)

コナン

• コナンセンター内に収録

 find_package(glaze REQUIRED)

target_link_libraries(main PRIVATE glaze::glaze)

ビルド2

• cppget で利用可能

 import libs = libglaze%lib{glaze}

Arch Linux

• AUR パッケージ: glaze および glaze-git

新しいプロジェクトで Glaze を使用する方法については、このサンプル リポジトリを参照してください。

---

よくある質問については FAQ を参照してください

明示的なメタデータ

リフレクションを特殊化したい場合は、オプションで以下のコードを記述できます。

このメタデータは、非集約初期化可能な構造体にも必要です。

 template <>
struct glz ::meta<my_struct> {
   using T = my_struct;
   static constexpr auto value = object(
      &T::i,
      &T::d,
      &T::hello,
      &T::arr,
      &T::map
   );
};

ローカルグレーズメタ

Glaze は、関連するクラス内のメタデータもサポートします。

 struct my_struct
{
  int i = 287 ;
  double d = 3.14 ;
  std::string hello = " Hello World " ;
  std::array< uint64_t , 3 > arr = { 1 , 2 , 3 };
  std::map<std::string, int > map{{ " one " , 1 }, { " two " , 2 }};
  
  struct glaze {
     using T = my_struct;
     static constexpr auto value = glz::object(
        &T::i,
        &T::d,
        &T::hello,
        &T::arr,
        &T::map
     );
  };
};

カスタムキー名または名前のないタイプ

Glaze メタデータを定義すると、オブジェクトにはメンバー オブジェクト ポインターの非静的名が自動的に反映されます。ただし、カスタム名が必要な場合、またはフィールドに名前を提供しないラムダ関数またはラッパーを登録する場合は、オプションでメタデータにフィールド名を追加できます。

カスタム名の例:

 template <>
struct glz ::meta<my_struct> {
   using T = my_struct;
   static constexpr auto value = object(
      " integer " , &T::i,
      " double " , &T::d,
      " string " , &T::hello,
      " array " , &T::arr,
      " my map " , &T::map
   );
};

これらの各文字列はオプションであり、名前を反映させたい場合は個々のフィールドで削除できます。

以下の名前が必要です。

• 静的 constexpr メンバー変数
• ラッパー
• ラムダ関数

リフレクションAPI

Glaze はglz::meta特殊化を介して変更できるコンパイル時リフレクション API を提供します。このリフレクション API はglz::meta特殊化が提供されていない限り、純粋なリフレクションを使用します。その場合、デフォルトの動作は開発者によってオーバーライドされます。

 static_assert (glz::reflect<my_struct>::size == 5 ); // Number of fields
static_assert (glz::reflect<my_struct>::keys[ 0 ] == " i " ); // Access keys 

警告

上記のglz::reflectフィールドは形式化されており、変更される可能性は低いです。 glz::reflect構造体の他のフィールドは、仕様の正式化を続けるにつれて進化する可能性があります。したがって、将来、文書化されていないフィールドに対して重大な変更が発生する可能性があります。

カスタム読み取り/書き込み

カスタムの読み取りと書き込みは、custom-serialization.md で説明されている強力to特殊化アプローチfrom実現できます。ただし、これはユーザー定義型に対してのみ機能します。

一般的な使用例や、特定のメンバー変数に特別な読み取りと書き込みが必要な場合は、 glz::custom使用して読み取り/書き込みメンバー関数、std::functions、または lambda 関数を登録できます。

例を参照してください:

 struct custom_encoding
{
   uint64_t x{};
   std::string y{};
   std::array< uint32_t , 3 > z{};
   
   void read_x ( const std::string& s) {
      x = std::stoi (s);
   }
   
   uint64_t write_x () {
      return x;
   }
   
   void read_y ( const std::string& s) {
      y = " hello " + s;
   }
   
   auto & write_z () {
      z[ 0 ] = 5 ;
      return z;
   }
};

template <>
struct glz ::meta<custom_encoding>
{
   using T = custom_encoding;
   static constexpr auto value = object( " x " , custom<&T::read_x, &T::write_x>, //
                                        " y " , custom<&T::read_y, &T::y>, //
                                        " z " , custom<&T::z, &T::write_z>);
};

suite custom_encoding_test = [] {
   " custom_reading " _test = [] {
      custom_encoding obj{};
      std::string s = R"( {"x":"3","y":"world","z":[1,2,3]} )" ;
      expect (! glz::read_json (obj, s));
      expect (obj. x == 3 );
      expect (obj. y == " helloworld " );
      expect (obj. z == std::array< uint32_t , 3 >{ 1 , 2 , 3 });
   };
   
   " custom_writing " _test = [] {
      custom_encoding obj{};
      std::string s = R"( {"x":"3","y":"world","z":[1,2,3]} )" ;
      expect (! glz::read_json (obj, s));
      std::string out{};
      expect ( not glz::write_json (obj, out));
      expect (out == R"( {"x":3,"y":"helloworld","z":[5,2,3]} )" );
   };
};

オブジェクトマッピング

メンバー ポインター (例: &T::a ) を使用する場合、C++ クラス構造は JSON インターフェイスと一致する必要があります。異なるレイアウトを持つ C++ クラスを同じオブジェクト インターフェイスにマップすることが望ましい場合があります。これは、メンバー ポインターの代わりにラムダ関数を登録することで実現されます。

 template <>
struct glz ::meta<Thing> {
   static constexpr auto value = object(
      " i " , []( auto && self) -> auto & { return self. subclass . i ; }
   );
};

ラムダ関数に渡される値self Thingオブジェクトになり、ラムダ関数を使用するとサブクラスをオブジェクト インターフェイスから非表示にすることができます。

Lambda 関数はデフォルトで戻り値をコピーするため、通常、glaze がメモリに書き込むにはauto&戻り値の型が必要です。

glaze は書き込み/読み取り時に値、ポインタ、および参照を同じ方法で扱うため、再マッピングはポインタ/参照を通じても実現できることに注意してください。

値のタイプ

クラスは次のように基になる値として扱うことができます。

 struct S {
  int x{};
};

template <>
struct glz ::meta<S> {
  static constexpr auto value{ &S::x };
};

またはラムダを使用します:

 template <>
struct glz ::meta<S> {
  static constexpr auto value = []( auto & self) -> auto & { return self. x ; };
};

エラー処理

Glaze は信頼できないメッセージに対して安全に使用できます。エラーは、通常、 std::expectedと同様に動作するglz::expected内でエラー コードとして返されます。

Glaze はエラー処理を短絡するように機能します。つまり、エラーが発生した場合、解析は非常に迅速に終了します。

さらに役立つエラー メッセージを生成するには、 format_errorを呼び出します。

 auto pe = glz::read_json(obj, buffer);
if (pe) {
  std::string descriptive_error = glz::format_error (pe, buffer);
}

このテストケース:

{ "Hello" : " World " x, "color": "red" }

次のエラーが発生します。

 1:17: expected_comma
   {"Hello":"World"x, "color": "red"}
                   ^

ここでは x が無効であることを示します。

入力バッファ (NULL) 終端

入力バッファには非 const std::string使用することをお勧めします。これにより、Glaze は一時的なパディングでパフォーマンスを向上させることができ、バッファは null で終了します。

JSON

デフォルトでは、オプションnull_terminatedはtrueに設定されており、JSON を解析するときに null で終了するバッファを使用する必要があります。このオプションをオフにすると、パフォーマンスがわずかに低下しますが、NULL で終了しないバッファーが許可されます。

 constexpr glz::opts options{. null_terminated = false };
auto ec = glz::read<options>(value, buffer); // read in a non-null terminated buffer 

ベベ

BEVE (バイナリ) を解析する場合、ヌル終了は必要ありません。パフォーマンスに違いはありません。

CSV

警告

現在、 null_terminated = false CSV 解析では無効であり、バッファーは null で終了する必要があります。

タイプのサポート

配列の種類

配列型は論理的に JSON 配列値に変換されます。概念は、さまざまなコンテナーを許可するために使用され、標準ライブラリー・インターフェースと一致する場合にはユーザー・コンテナーも許可します。

• glz::array (コンパイル時の混合型)
• std::tuple (コンパイル時の混合型)
• std::array
• std::vector
• std::deque
• std::list
• std::forward_list
• std::span
• std::set
• std::unordered_set

オブジェクトの種類

オブジェクト タイプは、マップなどの JSON オブジェクト値に論理的に変換されます。 JSON と同様に、Glaze はオブジェクト定義を順序付けされていないマップとして扱います。したがって、オブジェクト レイアウトの順序は、C++ の同じバイナリ シーケンスと一致する必要はありません。

• glz::object (コンパイル時の混合型)
• std::map
• std::unordered_map
• std::pair (スタックストレージ内の動的キーを有効にします)

std::pair単一のキーと値を持つオブジェクトとして扱われますが、 std::pair配列で使用される場合、Glaze はペアを単一のオブジェクトに連結します。 std::vector<std::pair<...>>単一のオブジェクトとしてシリアル化されます。この動作を望まない場合は、コンパイル時オプション.concatenate = falseを設定します。

バリエーション

• std::variant

詳細については、「バリアントの処理」を参照してください。

Null 許容型

• std::unique_ptr
• std::shared_ptr
• std::optional

Null 許容型は、有効な入力によって割り当てられるか、 nullキーワードによって無効化されることがあります。

std::unique_ptr< int > ptr{};
std::string buffer{};
expect ( not glz::write_json (ptr, buffer));
expect (buffer == " null " );

expect ( not glz::read_json (ptr, " 5 " ));
expect (*ptr == 5 );
buffer.clear();
expect ( not glz::write_json (ptr, buffer));
expect (buffer == " 5 " );

expect ( not glz::read_json (ptr, " null " ));
expect (! bool (ptr));

列挙型

デフォルトでは、列挙型は整数形式で書き込まれ、読み取られます。これが望ましい動作である場合、 glz::metaは必要ありません。

ただし、列挙型を JSON の文字列として使用したい場合は、次のようにglz::metaに登録できます。

 enum class Color { Red, Green, Blue };

template <>
struct glz ::meta<Color> {
   using enum Color;
   static constexpr auto value = enumerate(Red,
                                           Green,
                                           Blue
   );
};

使用中:

Color color = Color::Red;
std::string buffer{};
glz::write_json (color, buffer);
expect (buffer == " " Red " " );

コメント付きの JSON (JSONC)

コメントは、ここで定義された仕様でサポートされています: JSONC

コメントの読み取りサポートはglz::read_jsoncまたはglz::read<glz::opts{.comments = true}>(...)で提供されます。

JSON を美しくする

フォーマットされた JSON は、コンパイル時オプションを介して直接書き出すことができます。

 auto ec = glz::write<glz::opts{. prettify = true }>(obj, buffer);

または、JSON テキストはglz::prettify_json関数を使用してフォーマットできます。

std::string buffer = R"( {"i":287,"d":3.14,"hello":"Hello World","arr":[1,2,3]} )" );
auto beautiful = glz::prettify_json(buffer);

今はbeautifulです：

{
   "i" : 287 ,
   "d" : 3.14 ,
   "hello" : " Hello World " ,
   "arr" : [
      1 ,
      2 ,
      3
   ]
}

JSON を縮小する

縮小された JSON を書き込むには:

 auto ec = glz::write_json(obj, buffer); // default is minified

JSON テキスト呼び出しを縮小するには:

std::string minified = glz::minify_json(buffer);

縮小された JSON の読み取り

縮小された JSON が必要な場合、または入力が常に縮小されることがわかっている場合は、コンパイル時オプション.minified = true使用することで、パフォーマンスをもう少し向上させることができます。

 auto ec = glz::read<glz::opts{. minified = true }>(obj, buffer);

ブールフラグ

Glaze は、文字列オプションの配列として動作するブール型フラグのセットの登録をサポートしています。

 struct flags_t {
   bool x{ true };
   bool y{};
   bool z{ true };
};

template <>
struct glz ::meta< flags_t > {
   using T = flags_t ;
   static constexpr auto value = flags( " x " , &T::x, " y " , &T::y, " z " , &T::z);
};

例：

 flags_t s{};
expect (glz::write_json(s) == R"([ " x " , " z " ])");

"x"と"z"は true であるため、のみ書き出されます。バッファを読み取ると、適切なブール値が設定されます。

BEVE を記述する場合、 flagsブール値ごとに 1 ビットのみを使用します (バイト アラインメント)。

JSONのロギング

場合によっては、可能な限り効率的に JSON 構造をその場で書き出すことが必要な場合があります。 Glaze はタプルのような構造を提供し、構造をスタック割り当てして JSON を高速に書き出すことができます。これらの構造体は、オブジェクトの場合はglz::obj 、配列の場合はglz::arrという名前が付けられます。

以下は、配列を含むオブジェクトを構築し、それを書き出す例です。

 auto obj = glz::obj{ " pi " , 3.14 , " happy " , true , " name " , " Stephen " , " arr " , glz::arr{ " Hello " , " World " , 2 }};

std::string s{};
expect ( not glz::write_json (obj, s));
expect (s == R"( {"pi":3.14,"happy":true,"name":"Stephen","arr":["Hello","World",2]} )" );

このアプローチは、汎用 JSON のglz::json_tよりも大幅に高速です。ただし、すべての状況に適しているわけではありません。

マージ

glz::merge使用すると、ユーザーは複数の JSON オブジェクト タイプを 1 つのオブジェクトにマージできます。

glz::obj o{ " pi " , 3.141 };
std::map<std::string_view, int > map = {{ " a " , 1 }, { " b " , 2 }, { " c " , 3 }};
auto merged = glz::merge{o, map};
std::string s{};
glz::write_json (merged, s); // will write out a single, merged object
// s is now: {"pi":3.141,"a":0,"b":2,"c":3}

glz::mergeコピーを避けるために左辺値への参照を保存します

汎用 JSON

glz::json_tの汎用 JSON を参照してください。

glz:: json_t json{};
std::string buffer = R"( [5,"Hello World",{"pi":3.14}] )" ;
glz::read_json (json, buffer);
assert (json[ 2 ][ " pi " ].get< double >() == 3.14);

生バッファーのパフォーマンス

Glaze はstd::stringへの書き込みが、生の char バッファへの書き込みと同じくらい高速です。バッファーに十分なスペースが割り当てられている場合は、以下に示すように、生のバッファーに書き込むことができますが、これはお勧めできません。

 glz::read_json(obj, buffer);
const auto n = glz::write_json(obj, buffer.data()).value_or(0);
buffer.resize(n);

コンパイル時のオプション

glz::opts構造体は、読み取り/書き込みのためのコンパイル時のオプション設定を定義します。

glz::read_json(...)を呼び出す代わりに、 glz::read<glz::opts{}>(...)を呼び出してオプションをカスタマイズできます。

例: glz::read<glz::opts{.error_on_unknown_keys = false}>(...) 、不明なキーに関するエラーをオフにし、項目を単純にスキップします。

glz::opts形式を切り替えることもできます。

• glz::read<glz::opts{.format = glz::BEVE}>(...) -> glz::read_beve(...)
• glz::read<glz::opts{.format = glz::JSON}>(...) -> glz::read_json(...)

利用可能なコンパイル時オプション

以下の構造体は、使用可能なオプションとデフォルトの動作を示しています。

 struct opts {
  uint32_t format = json;
  bool comments = false ; // Support reading in JSONC style comments
  bool error_on_unknown_keys = true ; // Error when an unknown key is encountered
  bool skip_null_members = true ; // Skip writing out params in an object if the value is null
  bool use_hash_comparison = true ; // Will replace some string equality checks with hash checks
  bool prettify = false ; // Write out prettified JSON
  bool minified = false ; // Require minified input for JSON, which results in faster read performance
  char indentation_char = ' ' ; // Prettified JSON indentation char
  uint8_t indentation_width = 3 ; // Prettified JSON indentation size
  bool new_lines_in_arrays = true ; // Whether prettified arrays should have new lines for each element
  bool shrink_to_fit = false ; // Shrinks dynamic containers to new size to save memory
  bool write_type_info = true ; // Write type info for meta objects in variants
  bool error_on_missing_keys = false ; // Require all non nullable keys to be present in the object. Use
                                        // skip_null_members = false to require nullable members
  bool error_on_const_read =
     false ; // Error if attempt is made to read into a const value, by default the value is skipped without error
  bool validate_skipped = false ; // If full validation should be performed on skipped values
  bool validate_trailing_whitespace =
     false ; // If, after parsing a value, we want to validate the trailing whitespace

  uint8_t layout = rowwise; // CSV row wise output/input

  // The maximum precision type used for writing floats, higher precision floats will be cast down to this precision
  float_precision float_max_write_precision{};

  bool bools_as_numbers = false ; // Read and write booleans with 1's and 0's

  bool quoted_num = false ; // treat numbers as quoted or array-like types as having quoted numbers
  bool number = false ; // read numbers as strings and write these string as numbers
  bool raw = false ; // write out string like values without quotes
  bool raw_string =
     false ; // do not decode/encode escaped characters for strings (improves read/write performance)
  bool structs_as_arrays = false ; // Handle structs (reading/writing) without keys, which applies
  bool allow_conversions = true ; // Whether conversions between convertible types are
  // allowed in binary, e.g. double -> float

  bool partial_read =
     false ; // Reads into only existing fields and elements and then exits without parsing the rest of the input

  // glaze_object_t concepts
  bool partial_read_nested = false ; // Advance the partially read struct to the end of the struct
  bool concatenate = true ; // Concatenates ranges of std::pair into single objects when writing

  bool hide_non_invocable =
     true ; // Hides non-invocable members from the cli_menu (may be applied elsewhere in the future)
};

これらのコンパイル時オプションの多くには、オプションを 1 つのフィールドのみに適用するためのラッパーが含まれています。詳細については、「ラッパー」を参照してください。

JSON への準拠

デフォルトでは、Glaze は、関連するオプションを持つ 2 つの場合を除いて、最新の JSON 標準に厳密に準拠しています。

• validate_skippedこのオプションは、解析時にスキップされた値に対して完全な JSON 検証を実行します。通常、ユーザーが値に関心を持たない場合は値がスキップされ、Glaze は重大な問題について引き続き検証するため、これはデフォルトでは設定されません。ただし、スキップされる値が正確に JSON に準拠しているかどうかを気にする必要がないため、スキップが高速になります。たとえば、デフォルトでは、Glaze はスキップされた数値に有効な数字がすべて含まれていることを確認しますが、 validate_skippedがオンでない限り、スキップされた数値の先頭のゼロなどの問題は検証されません。 Glaze が使用する値を解析する場合、その値は完全に検証されます。
• validate_trailing_whitespaceこのオプションは、解析された文書内の末尾の空白を検証します。 Glaze は C++ 構造体を解析するため、通常、対象のオブジェクトが読み取られた後に解析を続ける必要はありません。ドキュメントの残りの部分に有効な空白があることを確認したい場合は、このオプションをオンにします。オンにしないと、Glaze は対象のコンテンツが解析された後、そのコンテンツを無視します。

注記

Glaze は、エスケープ制御文字 (例: "x1f"から"u001f" ) を自動的に Unicode 化しません。これは、文字列に null 文字やその他の非表示の文字が埋め込まれる危険性があるためです。これらの変換 (未解決の問題: Unicode エスケープ書き込み) を有効にするためにコンパイル時オプションが追加されますが、これはデフォルトの動作ではありません。

スキップ

エラーを防ぐためにオブジェクト内にキーが存在することを確認すると便利ですが、C++ ではその値が必要でないか、存在しない可能性があります。これらのケースはglz::skipタイプをメタデータに登録することで処理されます。

例を参照してください:

 struct S {
  int i{};
};

template <>
struct glz ::meta<S> {
  static constexpr auto value = object( " key_to_skip " , skip{}, &S::i);
};

std::string buffer = R"( {"key_to_skip": [1,2,3], "i": 7} )" ;
S s{};
glz::read_json (s, buffer);
// The value [1,2,3] will be skipped
expect (s.i == 7 ); // only the value i will be read into 

隠れる

Glaze は、汎用 API の構築を支援するように設計されています。場合によっては、値を API に公開する必要がありますが、JSON で値を読み込んだり書き出すことは望ましくありません。これはglz::hideの使用例です。

glz::hide API (および JSON ポインター) アクセスを許可しながら、JSON 出力から値を非表示にします。

例を参照してください:

 struct hide_struct {
  int i = 287 ;
  double d = 3.14 ;
  std::string hello = " Hello World " ;
};

template <>
struct glz ::meta<hide_struct> {
   using T = hide_struct;
   static constexpr auto value = object(&T::i,  //
                                        &T::d, //
                                        " hello " , hide{&T::hello});
};

hide_struct s{};
auto b = glz::write_json(s);
expect (b == R"( {"i":287,"d":3.14} )" ); // notice that "hello" is hidden from the output 

引用符で囲まれた数字

glz::quotedラッパーを利用すると、引用符で囲まれた JSON 数値をdouble 、 intなどの型に直接解析できます。

 struct A {
   double x;
   std::vector< uint32_t > y;
};

template <>
struct glz ::meta<A> {
   static constexpr auto value = object( " x " , glz::quoted_num<&A::x>, " y " , glz::quoted_num<&A::y>;
};

{
  "x" : " 3.14 " ,
  "y" : [ " 1 " , " 2 " , " 3 " ]
}

引用符で囲まれた JSON 数値は、 doubleおよびstd::vector<uint32_t>に直接解析されます。 glz::quoted関数は、ネストされたオブジェクトと配列に対しても機能します。

JSON 行 (NDJSON) のサポート

Glaze は、配列のような型 ( std::vectorやstd::tupleなど) の JSON Lines (または改行区切り JSON) をサポートします。

std::vector<std::string> x = { " Hello " , " World " , " Ice " , " Cream " };
std::string s = glz::write_ndjson(x).value_or( " error " );
auto ec = glz::read_ndjson(x, s);

その他の機能

データレコーダー

コマンドラインインターフェースメニュー

JSON インクルード システム

JSON ポインターの構文

JSON-RPC 2.0

JSONスキーマ

共有ライブラリAPI

タグ付きバイナリメッセージ

スレッドプール

タイムトレースプロファイリング

• パフォーマンス プロファイルを JSON に出力し、Perfetto を使用して視覚化する

ラッパー

拡張機能

拡張子については、 extディレクトリを参照してください。

• エイゲン
• JSON-RPC 2.0
• コマンドラインインターフェースメニュー (cli_menu)

ライセンス

Glaze は、埋め込みフォームを除き、MIT ライセンスに基づいて配布されます。

--- ライセンスに対するオプションの例外 ---

例外として、ソース コードをコンパイルした結果、本ソフトウェアの一部がそのソース コードの機械実行可能なオブジェクト形式に埋め込まれた場合、著作権および許可を含めることなく、その埋め込まれた部分をそのオブジェクト形式で再配布することができます。気づきます。