### Installing pytomlpp Python Wrapper

Source: https://marzer.github.io/tomlplusplus/index

This snippet shows the command to install the pytomlpp Python wrapper library, which provides a fast, natively-compiled TOML parser for Python, leveraging the toml++ library.

```shell
pip install pytomlpp
```

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

### Adding tomlplusplus via Meson

Source: https://marzer.github.io/tomlplusplus/index

Demonstrates how to install and use tomlplusplus with the Meson build system. It includes commands for wrapping the package and for declaring it as a dependency.

```shell
meson wrap install tomlplusplus

After that, you can use it like a regular dependency:
tomlplusplus_dep = dependency('tomlplusplus')
```

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

### Integrating tomlplusplus with Meson

Source: https://marzer.github.io/tomlplusplus/v3.3.0/index

This example shows how to install tomlplusplus using Meson's wrap system and then use it as a dependency in a Meson build file. It simplifies dependency management for Meson projects.

```meson
tomlplusplus_dep = dependency('tomlplusplus')

```

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

### Adding tomlplusplus via Vcpkg

Source: https://marzer.github.io/tomlplusplus/index

A simple command to install the tomlplusplus library using the Vcpkg package manager.

```shell
vcpkg install tomlplusplus
```

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

### YAML Configuration Example for tomlplusplus

Source: https://marzer.github.io/tomlplusplus/v3.1.0/index

This snippet illustrates the equivalent configuration in YAML format for the tomlplusplus project, mirroring the structure found in the JSON example.

```yaml
author:
  github: 'https://github.com/marzer'
  name: 'Mark Gillard'
  twitter: 'https://twitter.com/marzer8789'
cpp:
  - 17
  - 20
  - 'and beyond'
lib: toml++
repo: 'https://github.com/marzer/tomlplusplus/'
toml:
  - '1.0.0'
  - 'and beyond'
```

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

### Example of TOML configuration file

Source: https://marzer.github.io/tomlplusplus/v3.3.0/index

This is an example of a TOML configuration file, showcasing basic key-value pairs, nested tables, and arrays of values. This format is commonly used for configuration files and is processed by libraries like toml++.

```toml
author:
  github: 'https://github.com/marzer'
  name: 'Mark Gillard'
  twitter: 'https://twitter.com/marzer8789'
cpp:
  - 17
  - 20
  - 'and beyond'
lib: 'toml++'
repo: 'https://github.com/marzer/tomlplusplus/'
toml:
  - '1.0.0'
  - 'and beyond'

```

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

### Install pytomlpp using pip (Python)

Source: https://marzer.github.io/tomlplusplus/v2.5.0/index

This command installs the `pytomlpp` Python wrapper library, which provides a fast, natively-compiled TOML parser for Python, built around the toml++ C++ library.

```shell
pip install pytomlpp

```

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

### Example: Convert TOML to YAML using yaml_formatter

Source: https://marzer.github.io/tomlplusplus/classtoml_1_1yaml__formatter

Demonstrates how to parse a TOML string and then format it as YAML using the toml::yaml_formatter class. This example shows the basic usage for converting a valid TOML structure to its YAML representation.

```cpp
auto some_toml = toml::parse(R"(
    [fruit]
    apple.color = "red"
    apple.taste.sweet = true

    [fruit.apple.texture]
    smooth = true
)"sv);
std::cout << toml::yaml_formatter{ some_toml } << "\n";
```

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

### Adding tomlplusplus via Tipi.build

Source: https://marzer.github.io/tomlplusplus/index

Instructions for incorporating tomlplusplus into a tipi.build project by adding a specific entry to the '.tipi/deps' file.

```json
{
    "marzer/tomlplusplus": { }
}
```

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

### Add toml++ via Meson

Source: https://marzer.github.io/tomlplusplus/v3.4.0/index

Install the toml++ wrap for Meson and use it as a dependency in your Meson build system.

```meson
meson wrap install tomlplusplus

tomlplusplus_dep = dependency('tomlplusplus')
```

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

### Adding tomlplusplus via Git Submodules

Source: https://marzer.github.io/tomlplusplus/index

Instructions for including tomlplusplus in a project as a Git submodule, specifying the repository URL and the destination directory.

```shell
git submodule add --depth 1 https://github.com/marzer/tomlplusplus.git tomlplusplus
```

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

### Parsing Strings and IOStreams

Source: https://marzer.github.io/tomlplusplus/index

Shows how to parse TOML data directly from a string or an istream using `toml::parse()`. Includes exception handling.

```APIDOC
## POST /parse

### Description
Parses TOML data from a string or an input stream. Returns a `toml::table` on success or throws `toml::parse_error` on failure.

### Method
POST

### Endpoint
`/parse`

### Parameters
#### Query Parameters
- **sourceType** (string) - Required - Specifies whether the input is a 'string' or 'stream'.

#### Request Body
- **content** (string) - Required - The TOML content to parse, if `sourceType` is 'string'.
- **stream** (ReadableStream) - Required - The input stream containing TOML data, if `sourceType` is 'stream'.

### Request Example
```cpp
#include <iostream>
#include <sstream>
#include <toml++/toml.hpp>
using namespace std::string_view_literals;

int main()
{
    static constexpr std::string_view some_toml = R"(
        [library]
        name = "toml++"
        authors = ["Mark Gillard <mark.gillard@outlook.com.au>"]
        cpp = 17
    )"sv;

    try
    {
        // parse directly from a string view:
        {
        toml::table tbl = toml::parse(some_toml);
        std::cout << tbl << "\n";
        }

        // parse from a string stream:
        {
        std::stringstream ss{ std::string{ some_toml } };
        toml::table tbl = toml::parse(ss);
        std::cout << tbl << "\n";
        }
    }
    catch (const toml::parse_error& err)
    {
        std::cerr << "Parsing failed:\n" << err << "\n";
        return 1;
    }
    return 0;
}
```

### Response
#### Success Response (200)
- **table** (toml::table) - The parsed TOML data.

#### Response Example
```json
{
  "table": {
    "library": {
      "name": "toml++",
      "authors": ["Mark Gillard <mark.gillard@outlook.com.au>"],
      "cpp": 17
    }
  }
}
```

#### Error Response (400)
- **error** (string) - A message describing the parsing error.

#### Error Example
```json
{
  "error": "Parsing failed: ..."
}
```
```

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

### Parsing Files

Source: https://marzer.github.io/tomlplusplus/index

Demonstrates how to parse a TOML file using `toml::parse_file()`. It includes error handling for `toml::parse_error`.

```APIDOC
## POST /parse/file

### Description
Parses a TOML file and returns a `toml::table`. Handles `toml::parse_error` if parsing fails.

### Method
POST

### Endpoint
`/parse/file`

### Parameters
#### Path Parameters
- **filePath** (string) - Required - The path to the TOML file to parse.

### Request Body
This endpoint does not strictly require a request body, but a file path must be provided, typically via a form submission or query parameter if not directly in the URL.

### Request Example
```cpp
#include <iostream>
#include <toml++/toml.hpp>

int main(int argc, char** argv)
{
    toml::table tbl;
    try
    {
        tbl = toml::parse_file(argv[1]);
        std::cout << tbl << "\n";
    }
    catch (const toml::parse_error& err)
    {
        std::cerr << "Parsing failed:\n" << err << "\n";
        return 1;
    }
    return 0;
}
```

### Response
#### Success Response (200)
- **table** (toml::table) - The parsed TOML data.

#### Response Example
```json
{
  "table": {
    "key": "value"
  }
}
```

#### Error Response (400)
- **error** (string) - A message describing the parsing error.

#### Error Example
```json
{
  "error": "Parsing failed: ..."
}
```
```

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

### Integrate toml++ with DDS (package.json5)

Source: https://marzer.github.io/tomlplusplus/v2.4.0/index

This example shows how to declare tomlpp version 2.4.0 as a dependency in a package.json5 file, commonly used in environments that leverage DDS for package management.

```json
depends: [
    'tomlpp^2.4.0',
]
```

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

### Parsing TOML and getting source position (C++)

Source: https://marzer.github.io/tomlplusplus/structtoml_1_1source__position

This snippet demonstrates parsing a TOML file and retrieving the source position of a specific node. It uses `toml::parse_file` to load the TOML content and then accesses the `source().begin()` method of a retrieved node to get its starting position. The output shows the line and column number where the node was defined.

```cpp
auto table = toml::parse_file("config.toml"sv);
std::cout << "The node 'description' was defined at "sv
    << table.get("description")->source().begin()
    << "\n";
```

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

### Parse TOML String and Get Value Source (C++)

Source: https://marzer.github.io/tomlplusplus/structtoml_1_1source__region

Shows how to parse a TOML string and retrieve the source region information for a specific key ('bar'). It then prints a formatted string indicating where the value was found in the source. This example utilizes toml::parse and the source() method to pinpoint the location of data within the parsed string.

```cpp
auto tbl = toml::parse("bar = 42", "config.toml");

std::cout << "The value for 'bar' was found on "sv
    << tbl.get("bar")->source()
    << "\n";
```

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

### Value Retrieval Functions for tomlplusplus node_view

Source: https://marzer.github.io/tomlplusplus/v2.4.0/classtoml_1_1node__view

These functions retrieve the underlying data from a node view. They include getting a raw reference, getting the value as an optional type, getting the exact value, or getting the value with a default if it's not present.

```cpp
template <typename T>
auto ref() const → decltype(auto) noexcept 
    Gets a raw reference to the viewed node's underlying data. 


template <typename T>
auto value() const → optional<T> noexcept 
    Gets the value contained by the referenced node. 


template <typename T>
auto value_exact() const → optional<T> noexcept 
    Gets the value contained by the referenced node. 


template <typename T>
auto value_or(T&& default_value) const → auto noexcept 
    Gets the raw value contained by the referenced node, or a default.
```

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

### Safely Get Node with get()

Source: https://marzer.github.io/tomlplusplus/v3.2.0/classtoml_1_1table

The `get(key)` methods retrieve a pointer to the node associated with the given key. They return `nullptr` if the key is not found, providing a non-throwing way to access elements. Overloads support `std::string_view` and `std::wstring_view`.

```cpp
auto get(std::string_view key) -> node* noexcept;
auto get(std::string_view key) const -> const node* noexcept;
auto get(std::wstring_view key) -> node*;
auto get(std::wstring_view key) const -> const node*;

// Example usage:
if (node_ptr = root.get("optional_key")) {
    // Key exists, process node_ptr
}
```

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

### Constructor

Source: https://marzer.github.io/tomlplusplus/v3.4.0/classtoml_1_1table

Constructs a `toml::table` with initial key-value pairs.

```APIDOC
## `toml::table::table(std::initializer_list<impl::table_init_pair> kvps)`

### Description
Constructs a table with one or more initial key-value pairs.

### Method
Constructor

### Parameters
#### Request Body
- **kvps** (std::initializer_list<impl::table_init_pair>) - Required - A list of key-value pairs used to initialize the table.

### Request Example
```cpp
auto tbl = toml::table{
    { "foo", 1 },
    { "bar", 2.0 },
    { "kek", "three" }
};
std::cout << tbl << "\n";
```

### Response
#### Success Response (200)
N/A (Constructor)

#### Response Example
```json
{ foo = 1, bar = 2.0, kek = "three" }
```
```

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

### Construct toml::table with Initial Key-Value Pairs

Source: https://marzer.github.io/tomlplusplus/classtoml_1_1table

Demonstrates how to construct a toml::table using an initializer list of key-value pairs. This method allows for the creation of a table with predefined content. The output shows the formatted TOML representation of the constructed table.

```cpp
auto tbl = toml::table{
    { "foo", 1 },
    { "bar", 2.0 },
    { "kek", "three" }
};
std::cout << tbl << "\n";
```

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

### get()

Source: https://marzer.github.io/tomlplusplus/v3.0.1/classtoml_1_1table

The `get()` methods retrieves the node at a specific key.  Various overloads are provided for both string_view and wstring_view, const and non-const.

```APIDOC
## get(std::string_view key) noexcept

### Description
Gets the node at a specific key.

### Method
GET

### Endpoint
toml::table::get(std::string_view key) noexcept

### Parameters
#### Path Parameters
- **key** (std::string_view) - Required - The node's key.

### Response
#### Success Response (200)
- **node*** (node*) - A pointer to the node at the specified key, or nullptr.

### Request Example
```cpp
auto tbl = toml::table{
    { "a", 42, },
    { "b", "is the meaning of life, apparently." }
};
std::cout << R"(node ["a"] exists: )"sv << !!arr.get("a") << "\n";
std::cout << R"(node ["b"] exists: )"sv << !!arr.get("b") << "\n";
std::cout << R"(node ["c"] exists: )"sv << !!arr.get("c") << "\n";
if (auto val = arr.get("a"))
    std::cout << R"(node ["a"] was an )"sv << val->type() << "\n";
```

### Response
#### Success Response (200)
- **node*** (node*) - A pointer to the node at the specified key, or nullptr.

#### Response Example
```
node ["a"] exists: true
node ["b"] exists: true
node ["c"] exists: false
node ["a"] was an integer
```

## get(std::string_view key) const noexcept

### Description
Gets the node at a specific key (const overload).

### Method
GET

### Endpoint
toml::table::get(std::string_view key) const noexcept

### Parameters
#### Path Parameters
- **key** (std::string_view) - Required - The node's key.

### Response
#### Success Response (200)
- **const node*** (const node*) - A pointer to the node at the specified key, or nullptr.

## get(std::wstring_view key)

### Description
Gets the node at a specific key.

### Method
GET

### Endpoint
toml::table::get(std::wstring_view key)

### Parameters
#### Path Parameters
- **key** (std::wstring_view) - Required - The node's key.

### Response
#### Success Response (200)
- **node*** (node*) - A pointer to the node at the specified key, or nullptr.

## get(std::wstring_view key) const

### Description
Gets the node at a specific key (const overload).

### Method
GET

### Endpoint
toml::table::get(std::wstring_view key) const

### Parameters
#### Path Parameters
- **key** (std::wstring_view) - Required - The node's key.

### Response
#### Success Response (200)
- **const node*** (const node*) - A pointer to the node at the specified key, or nullptr.
```

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

### Constructors, Destructors, and Conversion Operators

Source: https://marzer.github.io/tomlplusplus/v3.4.0/classtoml_1_1value

Information on how to construct, copy, move, and assign toml::value objects.

```APIDOC
## Constructors, Destructors, Conversion Operators

### `value(Args && ... args) explicit noexcept(…)`
Constructs a TOML value.

### `value(const value& other) noexcept`
Copy constructor.

### `value(const value& other, value_flags flags) noexcept`
Copy constructor with flags override.

### `value(value&& other) noexcept`
Move constructor.

### `value(value&& other, value_flags flags) noexcept`
Move constructor with flags override.
```

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

### Serialize Data to TOML, JSON, and YAML with C++

Source: https://marzer.github.io/tomlplusplus/v3.0.1/index

Demonstrates serializing a C++ toml::table into TOML, JSON, and YAML formats using overloaded stream operators and dedicated formatters. This example shows how to create a toml::table with nested structures and then output it to standard output in different serialization formats.

```cpp
#include <iostream>
#include <toml++/toml.h>

int main()
{
   auto tbl = toml::table{
       { "lib", "toml++" },
       { "cpp", toml::array{ 17, 20, "and beyond" } },
       { "toml", toml::array{ "1.0.0", "and beyond" } },
       { "repo", "https://github.com/marzer/tomlplusplus/" },
       { "author", toml::table{
               { "name", "Mark Gillard" },
               { "github", "https://github.com/marzer" },
               { "twitter", "https://twitter.com/marzer8789" }
           }
       },
   };

   // serializing as TOML
   std::cout << "###### TOML ######" << "\n\n";
   std::cout << tbl << "\n\n";

   // serializing as JSON using toml::json_formatter:
   std::cout << "###### JSON ######" << "\n\n";
   std::cout << toml::json_formatter{ tbl } << "\n\n";

   // serializing as YAML using toml::yaml_formatter:
   std::cout << "###### YAML ######" << "\n\n";
   std::cout << toml::yaml_formatter{ tbl } << "\n\n";

   return 0;
}

```

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

### Get Raw Value Reference

Source: https://marzer.github.io/tomlplusplus/v2.4.0/classtoml_1_1value

The `ref()` function template is used to get a raw reference to a value node's underlying data. It supports lvalue, rvalue, and const lvalue references, and requires specifying the expected type `T`.

```cpp
template <typename T>
auto ref() & → impl::unwrap_node<T>& noexcept 
    Gets a raw reference to a value node's underlying data.

template <typename T>
auto ref() && → impl::unwrap_node<T>&& noexcept 
    Gets a raw reference to a value node's underlying data (rvalue overload).

template <typename T>
auto ref() const & → const impl::unwrap_node<T>& noexcept 
    Gets a raw reference to a value node's underlying data (const lvalue overload).
```

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

### C++ Type Casting: Get Specific Node Type

Source: https://marzer.github.io/tomlplusplus/classtoml_1_1value

Attempts to get a pointer to the node as a more specific node type. Overloads exist for both non-const and const access. Returns a pointer to the wrapped node if successful, otherwise `nullptr` or a pointer to a different node type.

```cpp
template <typename T>
auto as() → impl::wrap_node<T>* noexcept 
    Gets a pointer to the node as a more specific node type. 

template <typename T>
auto as() const → const impl::wrap_node<T>* noexcept 
    Gets a pointer to the node as a more specific node type (const overload).

auto as_boolean() → value<bool>* final noexcept 
    Returns a pointer to the value if it is a value<bool>, otherwise `nullptr`.

auto as_boolean() const → const value<bool>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<bool>, otherwise `nullptr`.

auto as_date() → value<date>* final noexcept 
    Returns a pointer to the value if it is a value<date>, otherwise `nullptr`.

auto as_date() const → const value<date>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<date>, otherwise `nullptr`.

auto as_date_time() → value<date_time>* final noexcept 
    Returns a pointer to the value if it is a value<date_time>, otherwise `nullptr`.

auto as_date_time() const → const value<date_time>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<date_time>, otherwise `nullptr`.

auto as_floating_point() → value<double>* final noexcept 
    Returns a pointer to the value if it is a value<double>, otherwise `nullptr`.

auto as_floating_point() const → const value<double>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<double>, otherwise `nullptr`.

auto as_integer() → value<int64_t>* final noexcept 
    Returns a pointer to the value if it is a value<int64_t>, otherwise `nullptr`.

auto as_integer() const → const value<int64_t>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<int64_t>, otherwise `nullptr`.

auto as_string() → value<std::string>* final noexcept 
    Returns a pointer to the value if it is a value<std::string>, otherwise `nullptr`.

auto as_string() const → const value<std::string>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<std::string>, otherwise `nullptr`.

auto as_time() → value<time>* final noexcept 
    Returns a pointer to the value if it is a value<time>, otherwise `nullptr`.

auto as_time() const → const value<time>* final noexcept 
    Returns a const-qualified pointer to the value if it is a value<time>, otherwise `nullptr`.
```

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

### Adding tomlplusplus via Conan

Source: https://marzer.github.io/tomlplusplus/index

Instructions for integrating the tomlplusplus library into a project using the Conan package manager. This involves specifying the library version in the conanfile.

```text
Add tomlplusplus/3.4.0 to your conanfile.
```

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

### toml::table Constructors

Source: https://marzer.github.io/tomlplusplus/v3.3.0/classtoml_1_1table

Details on how to construct a toml::table object, including initialization with key-value pairs.

```APIDOC
## TOML Table Constructors

### `toml::table::table(std::initializer_list<impl::table_init_pair> kvps) explicit`

Constructs a table with one or more initial key-value pairs.

#### Parameters

*   **kvps** (std::initializer_list<impl::table_init_pair>) - A list of key-value pairs used to initialize the table.

#### Request Example

```cpp
auto tbl = toml::table{
    { "foo", 1 },
    { "bar", 2.0 },
    { "kek", "three" }
};
std::cout << tbl << "\n";
```

#### Response Example

```json
{ foo = 1, bar = 2.0, kek = "three" }
```
```

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

### GET /websites/marzer_github_io_tomlplusplus/at_path

Source: https://marzer.github.io/tomlplusplus/classtoml_1_1node

Retrieves a view of a subnode using a fully-qualified TOML path.

```APIDOC
## GET /websites/marzer_github_io_tomlplusplus/at_path

### Description
Returns a view of the subnode matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/websites/marzer_github_io_tomlplusplus/at_path`

### Parameters
#### Query Parameters
- **path** (string) - Required - The "TOML path" to traverse.

### Request Example
```
GET /websites/marzer_github_io_tomlplusplus/at_path?path=foo.bar[2]
```

### Response
#### Success Response (200)
- **node_view** (object) - A view of the TOML node found at the specified path.

#### Response Example
```json
{
  "example": "2"
}
```
```

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

### toml::key Constructors

Source: https://marzer.github.io/tomlplusplus/v3.3.0/classtoml_1_1key

Showcases various constructors for the toml::key class, allowing initialization from different string types (std::string_view, std::string, const char*, std::wstring_view) and source regions.

```cpp
key() defaulted noexcept
key(std::string_view k, source_region&& src = {}) explicit
key(std::string_view k, const source_region& src) explicit
key(std::string&& k, source_region&& src = {}) explicit noexcept
key(std::string&& k, const source_region& src) explicit noexcept
key(const char* k, source_region&& src = {}) explicit
key(const char* k, const source_region& src) explicit
key(std::wstring_view k, source_region&& src = {}) explicit
key(std::wstring_view k, const source_region& src) explicit
```

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

### Get array element by index

Source: https://marzer.github.io/tomlplusplus/v3.1.0/classtoml_1_1array

Retrieves an element from the array at a specified index. `at()` throws `std::out_of_range` if the index is invalid, while `get()` returns a pointer (or `nullptr`) and `operator[]` provides direct access (behavior for invalid index is undefined, potentially leading to a crash).

```cpp
auto& element = arr.at(0);
const node* element_ptr = arr.get(1);
node& direct_access = arr[2];
const node& const_direct_access = arr[3];
```

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

### Parse TOML String and Stream with Exception Handling (C++)

Source: https://marzer.github.io/tomlplusplus/index

Shows how to parse TOML data from a string view or a string stream using toml::parse. It catches toml::parse_error exceptions for error handling. This example requires the toml++ library and the <sstream> header.

```cpp
#include <iostream>
#include <sstream>
#include <toml++/toml.hpp>
using namespace std::string_view_literals;

int main()
{
    static constexpr std::string_view some_toml = R"(
        [library]
        name = "toml++"
        authors = ["Mark Gillard <mark.gillard@outlook.com.au>"]
        cpp = 17
    )"sv;

    try
    {
        // parse directly from a string view:
        {
        toml::table tbl = toml::parse(some_toml);
        std::cout << tbl << "\n";
        }

        // parse from a string stream:
        {
        std::stringstream ss{ std::string{ some_toml } };
        toml::table tbl = toml::parse(ss);
        std::cout << tbl << "\n";
        }
    }
    catch (const toml::parse_error& err)
    {
        std::cerr << "Parsing failed:\n" << err << "\n";
        return 1;
    }

    return 0;

}
```

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

### Configuring tomlplusplus with Tipi.build

Source: https://marzer.github.io/tomlplusplus/v3.3.0/index

This snippet demonstrates how to add tomlplusplus as a dependency in a Tipi.build project by adding an entry to the `.tipi/deps` file. Tipi.build is a build system for C++ projects.

```json
{
    "marzer/tomlplusplus": { }
}

```

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

### Constructors, Destructors, and Conversion Operators

Source: https://marzer.github.io/tomlplusplus/v3.1.0/classtoml_1_1node__view

Details the various constructors, the default destructor, and conversion operators for `node_view`.

```APIDOC
## Constructors, Destructors, Conversion Operators

### `node_view() defaulted noexcept`

Constructs an empty `node_view` that does not reference any node.

### `node_view(viewed_type* node) explicit noexcept`

Constructs a `node_view` that references the given node pointer.

### `node_view(viewed_type& node) explicit noexcept`

Constructs a `node_view` that references the given node reference.

### `node_view(const node_view&) defaulted noexcept`

Copy constructor. Creates a new `node_view` that refers to the same node as the source `node_view`.

### `node_view(node_view&&) defaulted noexcept`

Move constructor. Creates a new `node_view` that takes ownership of the reference from the source `node_view`, leaving the source in a valid but unspecified state.

### `explicit operator bool() const noexcept`

Converts the `node_view` to a boolean. Returns `true` if the view references a node, and `false` otherwise.
```

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

### Suppressing Move Construction with toml::inserter in C++

Source: https://marzer.github.io/tomlplusplus/v3.3.0/structtoml_1_1inserter

Demonstrates how to use the 'inserter' helper class to prevent unintended move construction when creating nested toml::array objects. This is useful for ensuring the desired structure is maintained. It shows a 'bad' example where move construction occurs and a 'good' example using 'inserter'.

```cpp
#include <iostream>
#include <toml++/toml.h>

int main() {
    // desired result: [ [ 42 ] ]
    auto bad = toml::array{ toml::array{ 42 } };
    auto good = toml::array{ toml::inserter{ toml::array{ 42 } } };

    std::cout << "bad: " << bad << "\n";
    std::cout << "good:" << good << "\n";

    return 0;
}
```

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

### GET /at_path (node&, toml::path path)

Source: https://marzer.github.io/tomlplusplus/v3.4.0/namespacetoml

Retrieves a view of a node using a toml::path object.

```APIDOC
## GET /at_path (node&, toml::path path)

### Description
Returns a view of the node matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/at_path`

### Parameters
#### Path Parameters
- **root** (node&) - Required - The root node from which the path will be traversed.
- **path** (const toml::path&) - Required - The "TOML path" to traverse.

### Request Example
```cpp
auto config = toml::parse(R"(

[foo]
bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]

)"sv);

toml::path path1("foo.bar[2]");
toml::path path2("foo.bar[4].kek");
std::cout << toml::at_path(config, path1) << "\n";
std::cout << toml::at_path(config, path1.parent_path()) << "\n";
std::cout << toml::at_path(config, path2) << "\n";
std::cout << toml::at_path(config, path2.parent_path()) << "\n";
```

### Response
#### Success Response (200)
- **node_view<node>**: A view of the node at the specified path.

#### Response Example
```
2
[ 0, 1, 2, [ 3 ], { kek = 4 } ]
4
{ kek  = 4 }
```

#### Note
Keys in paths are interpreted literally, so whitespace (or lack thereof) matters:
```
toml::at_path(config, toml::path("foo.bar"))  // same as config["foo"]["bar"]
toml::at_path(config, toml::path("foo. bar")) // same as config["foo"][" bar"]
toml::at_path(config, toml::path("foo..bar")) // same as config["foo"][""]["bar"]
toml::at_path(config, toml::path(".foo.bar")) // same as config[""]["foo"]["bar"]
```

Additionally, TOML allows '.' (period) characters to appear in keys if they are quoted strings. This function makes no allowance for this, instead treating all period characters as sub-table delimiters.
```

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

### Format and Print TOML Objects to Stream (C++)

Source: https://marzer.github.io/tomlplusplus/classtoml_1_1toml__formatter

Demonstrates how to use the toml::toml_formatter to print a TOML table to a standard output stream. It shows that direct printing of the table is equivalent to using the toml_formatter wrapper. Dependencies include the tomlplusplus library.

```cpp
auto tbl = toml::table{
    { "description", "This is some TOML, yo." },
    { "fruit", toml::array{ "apple", "orange", "pear" } },
    { "numbers", toml::array{ 1, 2, 3, 4, 5 } },
    { "table", toml::table{ { "foo", "bar" } } }
};

// these two lines are equivalent:
std::cout << toml::toml_formatter{ tbl } << "\n";
std::cout << tbl << "\n";
```

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

### GET /at_path (node&, wstring_view path)

Source: https://marzer.github.io/tomlplusplus/v3.4.0/namespacetoml

Retrieves a view of a node using a wide string-based TOML path.

```APIDOC
## GET /at_path (node&, wstring_view path)

### Description
Returns a view of the node matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/at_path`

### Parameters
#### Path Parameters
- **root** (node&) - Required - The root node from which the path will be traversed.
- **path** (std::wstring_view) - Required - The "TOML path" to traverse.

### Response
#### Success Response (200)
- **node_view<node>**: A view of the node at the specified path.
```

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

### GET /websites/marzer_github_io_tomlplusplus/at_path

Source: https://marzer.github.io/tomlplusplus/v3.4.0/classtoml_1_1node

Retrieves a view of a subnode matching a fully-qualified TOML path.

```APIDOC
## GET /websites/marzer_github_io_tomlplusplus/at_path

### Description
Returns a view of the subnode matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/websites/marzer_github_io_tomlplusplus/at_path`

### Parameters
#### Query Parameters
- **path** (string) - Required - The "TOML path" to traverse.

### Request Example
```json
{
  "path": "foo.bar[2]"
}
```

### Response
#### Success Response (200)
- **node_view<node>** - A view of the requested subnode.

#### Response Example
```json
2
```

#### Example Usage
```cpp
auto config = toml::parse(R"(

[foo]
bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]

)"sv);

std::cout << config.at_path("foo.bar[2]") << "\n";
std::cout << config.at_path("foo.bar[3][0]") << "\n";
std::cout << config.at_path("foo.bar[4].kek") << "\n";
```

#### Example Output
```
2
3
4
```
```

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

### Table Constructor

Source: https://marzer.github.io/tomlplusplus/v3.1.0/classtoml_1_1table

Constructs a TOML table with initial key-value pairs.

```APIDOC
## Table Constructor

### `table(std::initializer_list<impl::table_init_pair> kvps) explicit`

Constructs a table with one or more initial key-value pairs.

**Parameters**

* `kvps` (std::initializer_list<impl::table_init_pair>) - A list of key-value pairs used to initialize the table.

**Example**

```cpp
auto tbl = toml::table{
    { "foo", 1 },
    { "bar", 2.0 },
    { "kek", "three" }
};
std::cout << tbl << "\n";
```

**Output**

```
{ foo = 1, bar = 2.0, kek = "three" }
```
```

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

### GET /at_path (const node&, string_view path)

Source: https://marzer.github.io/tomlplusplus/v3.4.0/namespacetoml

Retrieves a const view of a node using a string-based TOML path.

```APIDOC
## GET /at_path (const node&, string_view path)

### Description
Returns a const view of the node matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/at_path`

### Parameters
#### Path Parameters
- **root** (const node&) - Required - The root node from which the path will be traversed.
- **path** (std::string_view) - Required - The "TOML path" to traverse.

### Response
#### Success Response (200)
- **node_view<const node>**: A const view of the node at the specified path.
```

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

### Formatted TOML Output Example (TOML)

Source: https://marzer.github.io/tomlplusplus/classtoml_1_1toml__formatter

This snippet shows the expected formatted TOML output corresponding to the C++ code that creates a TOML table. It serves as a reference for the structure and syntax of the output generated by toml::toml_formatter.

```toml
description = "This is some TOML, yo."
fruit = ["apple", "orange", "pear"]
numbers = [1, 2, 3, 4, 5]

[table]
foo = "bar"
```

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

### GET /at_path (string_view path)

Source: https://marzer.github.io/tomlplusplus/v3.4.0/namespacetoml

Retrieves a view of a node within the TOML structure using a string-based TOML path.

```APIDOC
## GET /at_path (string_view path)

### Description
Returns a view of the node matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/at_path`

### Parameters
#### Path Parameters
- **root** (node&) - Required - The root node from which the path will be traversed.
- **path** (std::string_view) - Required - The "TOML path" to traverse.

### Request Example
```cpp
auto config = toml::parse(R"(

[foo]
bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]

)"sv);

std::cout << toml::at_path(config, "foo.bar[2]") << "\n";
std::cout << toml::at_path(config, "foo.bar[3][0]") << "\n";
std::cout << toml::at_path(config, "foo.bar[4].kek") << "\n";
```

### Response
#### Success Response (200)
- **node_view<node>**: A view of the node at the specified path.

#### Response Example
```
2
3
4
```

#### Note
Keys in paths are interpreted literally, so whitespace (or lack thereof) matters:
```
toml::at_path(config, "foo.bar")  // same as config["foo"]["bar"]
toml::at_path(config, "foo. bar") // same as config["foo"][" bar"]
toml::at_path(config, "foo..bar") // same as config["foo"][""]["bar"]
toml::at_path(config, ".foo.bar") // same as config[""]["foo"]["bar"]
```

Additionally, TOML allows '.' (period) characters to appear in keys if they are quoted strings. This function makes no allowance for this, instead treating all period characters as sub-table delimiters. If you have periods in your table keys, first consider:
  1. Not doing that
  2. Using node_view::operator[] instead.
```

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

### GET /at_path (const node&, toml::path path)

Source: https://marzer.github.io/tomlplusplus/v3.4.0/namespacetoml

Retrieves a const view of a node using a toml::path object.

```APIDOC
## GET /at_path (const node&, toml::path path)

### Description
Returns a const view of the node matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/at_path`

### Parameters
#### Path Parameters
- **root** (const node&) - Required - The root node from which the path will be traversed.
- **path** (const toml::path&) - Required - The "TOML path" to traverse.

### Response
#### Success Response (200)
- **node_view<const node>**: A const view of the node at the specified path.
```

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

### Adding tomlplusplus via CMake FetchContent

Source: https://marzer.github.io/tomlplusplus/index

This snippet illustrates how to add tomlplusplus as a dependency in a CMake project using the FetchContent module, specifying the Git repository and tag.

```cmake
include(FetchContent)
FetchContent_Declare(
    tomlplusplus
    GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
    GIT_TAG v3.4.0
)
FetchContent_MakeAvailable(tomlplusplus)
```

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

### GET /at_path (const node&, wstring_view path)

Source: https://marzer.github.io/tomlplusplus/v3.4.0/namespacetoml

Retrieves a const view of a node using a wide string-based TOML path.

```APIDOC
## GET /at_path (const node&, wstring_view path)

### Description
Returns a const view of the node matching a fully-qualified "TOML path".

### Method
GET

### Endpoint
`/at_path`

### Parameters
#### Path Parameters
- **root** (const node&) - Required - The root node from which the path will be traversed.
- **path** (std::wstring_view) - Required - The "TOML path" to traverse.

### Response
#### Success Response (200)
- **node_view<const node>**: A const view of the node at the specified path.
```

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

### Get Node as Table (C++)

Source: https://marzer.github.io/tomlplusplus/v3.0.1/classtoml_1_1value

Attempts to retrieve the node as a table type. For specific node types, this will return nullptr as they cannot be tables.

```cpp
auto as_table() → table* final noexcept;

auto as_table() const → const table* final noexcept;
```

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

### Working with TOML Data using C++

Source: https://marzer.github.io/tomlplusplus/index

Demonstrates how to parse TOML data and access its elements using toml::node_view, toml::value, toml::array, and toml::table. It covers direct querying, type checking, modification of arrays, and navigating nested tables.

```cpp
#include <iostream>
#include <toml++/toml.hpp>
using namespace std::string_view_literals;

int main()
{
    static constexpr auto source = R"(
        str = "hello world"

        numbers = [ 1, 2, 3, "four", 5.0 ]
        vegetables = [ "tomato", "onion", "mushroom", "lettuce" ]
        minerals = [ "quartz", "iron", "copper", "diamond" ]

        [animals]
        cats = [ "tiger", "lion", "puma" ]
        birds = [ "macaw", "pigeon", "canary" ]
        fish = [ "salmon", "trout", "carp" ]
    )"sv;
    toml::table tbl = toml::parse(source);

    // different ways of directly querying data
    std::optional<std::string_view> str1 = tbl["str"].value<std::string_view>();
    std::optional<std::string>      str2 = tbl["str"].value<std::string>();
    std::string_view                str3 = tbl["str"].value_or(""sv);
    std::string&                    str4 = tbl["str"].ref<std::string>(); // ~~dangerous~~

    std::cout << *str1 << "\n";
    std::cout << *str2 << "\n";
    std::cout << str3 << "\n";
    std::cout << str4 << "\n";

    // get a toml::node_view of the element 'numbers' using operator[]
    auto numbers = tbl["numbers"];
    std::cout << "table has 'numbers': " << !!numbers << "\n";
    std::cout << "numbers is an: " << numbers.type() << "\n";
    std::cout << "numbers: " << numbers << "\n";

    // get the underlying array object to do some more advanced stuff
    if (toml::array* arr = numbers.as_array())
    {
        // visitation with for_each() helps deal with heterogeneous data
        arr->for_each([](auto&& el)
        {
            if constexpr (toml::is_number<decltype(el)>)
                (*el)++;
            else if constexpr (toml::is_string<decltype(el)>)
                el = "five"sv;
        });

        // arrays are very similar to std::vector
        arr->push_back(7);
        arr->emplace_back<toml::array>(8, 9);
        std::cout << "numbers: " << numbers << "\n";
    }

    // node-views can be chained to quickly query deeper
    std::cout << "cats: " << tbl["animals"]["cats"] << "\n";
    std::cout << "fish[1]: " << tbl["animals"]["fish"][1] << "\n";

    // can also be retrieved via absolute path
    std::cout << "cats: " << tbl.at_path("animals.cats") << "\n";
    std::cout << "fish[1]: " << tbl.at_path("animals.fish[1]") << "\n";

    // ...even if the element doesn't exist
    std::cout << "dinosaurs: " << tbl["animals"]["dinosaurs"] << "\n"; //no dinosaurs :(

    return 0;

}

```

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

### toml::key begin() method

Source: https://marzer.github.io/tomlplusplus/v3.2.0/classtoml_1_1key

Returns a constant iterator pointing to the first character of the key's internal string representation. This method is part of the iteration protocol for `toml::key` objects.

```cpp
auto begin() const → const_iterator noexcept
```

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

### Get Node as Array (C++)

Source: https://marzer.github.io/tomlplusplus/v3.0.1/classtoml_1_1value

Attempts to retrieve the node as an array type. For specific node types, this will return nullptr as they cannot be arrays.

```cpp
auto as_array() → array* final noexcept;

auto as_array() const → const array* final noexcept;
```

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

### Add toml++ via tipi.build

Source: https://marzer.github.io/tomlplusplus/v3.4.0/index

Include toml++ in your tipi.build projects by adding the specified entry to your .tipi/deps file.

```json
{
"marzer/tomlplusplus": { }
}
```

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

### toml::node_view::value_or

Source: https://marzer.github.io/tomlplusplus/v3.3.0/classtoml_1_1node__view

Gets the raw value contained by the referenced node, or a default value if retrieval or conversion fails.

```APIDOC
## GET /websites/marzer_github_io_tomlplusplus/node_view/value_or

### Description
Gets the raw value contained by the referenced node, or a default. If the node wasn't a value, wasn't the correct type, or no conversion was possible, the provided default value is returned.

### Method
GET (Conceptual - This is a C++ function, not a REST endpoint)

### Endpoint
N/A (C++ function)

### Parameters
#### Template Parameters
- **ViewedType** - The type of the viewed node.
- **T** - Default value type. Must be one of the native TOML value types, or convertible to it.

#### Parameters
- **default_value** (T) - The default value to return if the node retrieval or conversion fails.

### Response
#### Success Response
- **Value or default** (Type: `T`) - The underlying value if successfully retrieved and converted, otherwise the provided `default_value`.
```