### Iterating GSON C++ Document Elements

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Provides a loop example to iterate through all elements in a parsed Gson::doc. It shows how to access the index, type, key, value, and parent index of each element.

```CPP
for (uint16_t i = 0; i <doC.length (); i ++) {
    // if (doc.type (i) == gson :: type :: Object || doc.type (i) == gson :: type :: array) Continue;// Skip containers
    Serial.print (i);
    Serial.print (".. [");
    Serial.print (doc.readtype (i));
    Serial.print ("]");
    Serial.print (doc.key (i));
    Serial.print (":");
    Serial.print (doc.value (i));
    Serial.print ("{");
    Serial.print (doc.part (i));
    Serial.println ("}");
}
```

--------------------------------

### Building JSON String with Gson::String (CPP)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Provides a comprehensive example of building a JSON object and array programmatically using the `Gson::String` class. Shows methods for starting/ending objects/arrays, adding various data types (string, int, float, bool), and accessing elements like a map.

```CPP
Gson :: String GS;// Create a line
gs.beginobj ();// Start object 1
GS.Addstr ("str1", f ("value"));// Add a string value
GS ["str2"] = "value2";// So you can also
GS ["int"] = 12345;// integer
GS.Beginobj ("Obj");// invested object 2
GS.Addfloat (Float), 3.14);// Float
GS ["float2"] = 3.14;// or so
GS ["Bool"] = false;// Bool value
gs.ndobj ();// Complete object 2

GS.Beginarr ("Array");// Start an array
GS.Addfloat (3.14);// to array - without key
GS += "Text";
GS += 12345;
GS += True;
gs.ndarr ();// End the array

gs.ndobj ();// Complete object 1

gs.end ();// complete the package (necessarily called at the end)

Serial.println (GS);// Conclusion to the port
```

--------------------------------

### Comparing GSON Element Hash Value (CPP)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Shows how to get the hash value of a GSON element using the `.Hash()` method. This is typically used in conjunction with `SH()` for efficient comparison in control structures like switch statements.

```CPP
switch (doc [SH ("str")]. Hash ()) {
    Case SH ("SOME TEXT"):
    // ...
}
```

--------------------------------

### Gson Entry Class Methods (C++)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Details the methods available for a Gson Entry object, used to access and inspect individual elements within a parsed JSON document or array, including getting nested elements, checking validity, and retrieving key/value/type information.

```C++
Entry Get (Anytext Key);// get an element by key
Bool Includes (Anytext Key);// contains an element with the specified key

Entry Get (Size_t Hash);// Get the element according to the Key Hash
Bool Includes (Size_t Hash);// contains an element with the indicated Key Hash

Entry Get (Int Index);// Get an index element

Bool Valid ();// Checking correctness (existence)
uint16_t Length ();// Get the size (for objects and arrays. For the rest 0)
Type type ();// get the type of element
Anytext Key ();// Get the key
size_t keyhash ();// Get a keys of the key
Anytext Value ();// get a value
```

--------------------------------

### Accessing GSON C++ Document Values

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Demonstrates various ways to access values within a parsed Gson::doc using array-like syntax doc[...]. Shows access by string key, Flash string key (f(...)), integer index, nested access, type conversion (toint16(), auto-conversion), and type checking (Type()). Includes examples for objects and arrays.

```CPP
Serial.println (doc ["key"]);// Value
Serial.println (doc [f ("int")]);// 12345
int Val = doc ["int"]. toint16 ();// Conversion into the specified type
val = doc ["int"];// Auto Convertation
Float F = doc ["Obj"] ["Float"];// invested object
Serial.println (doc ["arr"] [0]);// Hello
Serial.println (doc ["arr"] [1]);// True

// Type check
doc ["arr"]. Type () == gson :: type :: array;

// Conclusion of the contents of the array
for (int i = 0; i <doc ["arr"]. Length (); i ++) {
    Serial.println (doc ["arr"] [i]);
}

// and better - so
Gson :: Entry Arr = doc ["arr"];
for (int i = 0; i <arr.length (); i ++) {
    Serial.println (arr [i]);
}

// Let json have the form [[123,456], ["ABC", "Def"]], then you can turn to the nested arrays:
Serial.println (doc [0] [0]);// 123
Serial.println (doc [0] [1]);// 456
Serial.println (doc [1] [0]);// ABC
Serial.println (doc [1] [1]);// Def
```

--------------------------------

### Creating GSON C++ Document Objects

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Demonstrates how to create dynamic and static Gson::doc objects for parsing JSON, explaining the purpose of reserving size and the difference between dynamic and static allocation.

```CPP
Gson :: doc doc;// Dynamic document
Gson :: doc doc (10);// Dynamic document reserved for 10 elements
GSON :: doCstatic <10> doc;// Static document reserved for 10 elements
```

--------------------------------

### GSON C++ String Building Methods

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Lists the methods available for building a JSON string using the GSON::String class, including adding keys, raw text, strings, booleans, floats, integers, and managing object/array structure.

```CPP
String S;// Access to the line
Void Clear ();// Clean the line
Bool Reserve (Uint16_T Res);// Reserve a line

// Add Gson :: String.A comma will be added
String & Add (Constation String & STR);

// Add the key (string of any type)
String & Addkey (Anytext Key);

// add text (string of any type)
String & Addraw (Anytext Str, Bool ESC = FALSE);

// Add a line (a string of any type)
String & Addstr (Anytext Key, Anytext Value);
String & Addstr (Anytext Value);

// Add bool
String & Addbool (Anytext Key, Const Bool & Value);
String & Addbool (Const Bool & Value);

// Add Float
String & Addfloat (Anytext Key, const Double & Value, Uint8_t Dec = 2);
String & Addfloat (Constance Double & Value, Uint8_t Dec = 2);

// Add int
String & Addint (Anytext Key, Const ANYVALUE & VALUE);
String & Addint (Const ANYVALUE & VALUE);

String & Beginobj (Anytext Key = "");// Start an object
String & Endobj ();// Complete the object

String & Beginarr (Anytext Key = "");// Start an array
String & Endarr ();// End the array

String & End ();// complete the package
```

--------------------------------

### Using GSON C++ Entry Objects

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Shows how to obtain a Gson::Entry object for a specific element (like an array) using doc[...] and then access its properties (LENGTH()) and elements (E[...]) directly, avoiding repeated lookups in the main document.

```CPP
GSON :: Entry E = doc ["arr"];
Serial.println (E.LENGTH ());// The length of the array
Serial.println (E [0]);// Hello
Serial.println (E [1]);// True
```

--------------------------------

### Accessing GSON Elements by Hashed Key (CPP)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Demonstrates accessing GSON document elements using the `SH()` macro with hashed keys. The `SH()` macro computes the hash at compile time, substituting a number for the string, which improves performance.

```CPP
USing Sutil :: SH;

VOID FOO () {
    Serial.println (doc [SH ("int")]);
    Serial.println (doc [SH ("Obj")] [SH ("Float")]);
    Serial.println (doc [SH ("Array")] [0]);
}
```

--------------------------------

### Gson Document Class Methods (C++)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Defines the constructors and core methods available for interacting with a Gson document object, including parsing, accessing elements by key or index, checking for errors, and serializing the document.

```C++
// Designer
Gson :: doc ();
GSON :: doc (size);
GSON :: doCstatic <size> ();

// Methods
uint16_t Length ();// get the number of elements
uint16_t size ();// get the size of the document in RAM (byte)
Void Hashkeys ();// Heshcht the keys of all elements (the operation is irreversible)
Bool Hashed ();// Checking whether the keys were drunken

Entry Get (Anytext Key);// Key access (main container - Object)
Entry Get (Size_t Hash);// Access to Hash Key (main container - Object)
Entry Get (Int Index);// Access by index (main container - Array or Object)

Anytext Key (Intx);// Read the key on the index
size_t keyhash (int IDX);// Read the Hesh key on the index
Anytext Value (Intx);// Read the value by index
int8_t part (int itx);// Read the parent on the index
Type Type (int IDX);// get the type of index

const __flashstringhelper* readtype (Uint16_T IDX);// Read the type of index

// Parish.True will return with successful parsing.You can specify Max.The level of investment
Bool Parse (String & Json, Uint8_t Maxdepth = 16);
Bool Parse (Const Char* Json, Uint8_t Maxdepth = 16);

// Bring out to Print with formatting
VOID stringify (print& p);

// error processing
Bool Haserror ();// there is a parsing error
Error Geterror ();// get an error
uint16_t errorindex ();// Index of the place of error in the line
const __flashstringhelper* readerror ();// Read the error
```

--------------------------------

### Hashing GSON Document Keys (CPP)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Hashes the keys within a GSON document using `doc.hashkeys()` for faster access. Note that this operation is irreversible and prevents reading keys in text form.

```CPP
doc.hashkeys ();
```

--------------------------------

### Parsing JSON String with GSON C++

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Shows how to parse a C-style string or String object containing JSON using doc.parse(). Includes error checking using doc.Haserror(), doc.earaderror(), and doc.errorindex(). Notes that parsing modifies the original string.

```CPP

```

--------------------------------

### Gson Parsing Error Codes (C++)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Lists the specific error codes that the Gson library can return to indicate issues encountered during the JSON parsing process, such as allocation failures, depth limits, or malformed tokens.

```C++
None
Alloc
Toodeep
NopARENT
NotContainer
UNEXCOMMA
Unexcolon
UNEXTOKEN
Unexquotes
Unexopen
Unexclose
Unknowntoken
Brokentoken
Brokenstring
BrokenContainer
Emptyky
Indexoverflow
```

--------------------------------

### Gson Element Types (C++)

Source: https://github.com/gyverlibs/gson/blob/main/README_EN.md

Enumerates the different data types that a JSON element can represent within the Gson library, such as Object, Array, String, numbers, and boolean.

```C++
None
Object
Array
String
Int
Float
Bool
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.