Glaze

https://github.com/stephenberry/glaze
Admin
Glaze is an exceptionally fast JSON library that reads and writes directly from object memory,...
Tokens:1,035,980
Snippets:6,458
Trust Score:9.5
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### Complete Working Example: main.cpp

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

A minimal Glaze HTTP server that responds to GET /hello with a JSON message. Binds to 127.0.0.1:8080, starts the server, and waits for a signal to shut down.

```cpp
// main.cpp
#include "glaze/net/http_server.hpp"
#include <iostream>

int main() {
    glz::http_server server;

    server.get("/hello", [](const glz::request&, glz::response& res) {
        res.json({{"message", "Hello from Glaze!"}});
    });

    server.bind("127.0.0.1", 8080).with_signals();

    std::cout << "Server running on http://127.0.0.1:8080\n";

    server.start();
    server.wait_for_signal();

    return 0;
}
```

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

### Mixed HTTP/HTTPS server setup

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/tls-support.md

This example shows how to run both an HTTP server (glz::http_server<>) and an HTTPS server (glz::https_server) in the same application. The HTTP server serves public content on port 8080, while the HTTPS server loads a certificate and serves secure content on port 8443. Both servers are started on separate threads and joined at the end.

```cpp
#include "glaze/net/http_server.hpp"

int main() {
    // HTTP server for public content
    glz::http_server<> http_server;
    http_server.get("/", [](const glz::request& req, glz::response& res) {
        res.body("Public HTTP content");
    });
    
    // HTTPS server for secure content
    glz::https_server https_server;
    https_server.load_certificate("cert.pem", "key.pem")
                .get("/secure", [](const glz::request& req, glz::response& res) {
                    res.body("Secure HTTPS content");
                });
    
    // Start both servers
    std::thread http_thread([&]() { 
        http_server.bind(8080).start(); 
    });
    
    std::thread https_thread([&]() { 
        https_server.bind(8443).start(); 
    });
    
    http_thread.join();
    https_thread.join();
    
    return 0;
}
```

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

### Basic HTTP Server with glz::http_server

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/http-rest-support.md

Sets up a minimal HTTP server that responds to GET /hello with 'Hello, World!'. The start() method is non-blocking, so the main thread blocks on wait_for_signal() until shutdown. with_signals() enables Ctrl+C (SIGINT) handling.

```cpp
#include "glaze/net/http_server.hpp"
#include <iostream>

int main() {
    glz::http_server server;
    
    server.get("/hello", [](const glz::request& /*req*/, glz::response& res) {
        res.body("Hello, World!");
    });
    
    // Note: start() is non-blocking; block the main thread until shutdown
    server.bind("127.0.0.1", 8080)
          .with_signals(); // enable Ctrl+C (SIGINT) handling

    std::cout << "Server running on http://127.0.0.1:8080\n";
    std::cout << "Press Ctrl+C to stop\n";

    server.start();
    server.wait_for_signal();
    return 0;
}
```

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

### HTTPS Server Setup with SSL Certificates

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/advanced-networking.md

Creates an HTTPS server using glz::https_server, loads SSL certificates, and optionally configures client certificate verification. Sets up a secure route and starts the server on port 8443.

```cpp
#include "glaze/net/http_server.hpp"

// Create HTTPS server (EnableTLS template parameter)
glz::https_server server;  // or glz::http_server<true>

// Load SSL certificates
server.load_certificate("server-cert.pem", "server-key.pem");

// Configure SSL options
server.set_ssl_verify_mode(0); // No client certificate verification

// Optional: Require client certificates
// server.set_ssl_verify_mode(SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT);

// Setup routes as normal
server.get("/secure-data", [](const glz::request& req, glz::response& res) {
    res.json({
        {"secure", true},
        {"client_ip", req.remote_ip},
        {"timestamp", std::time(nullptr)}
    });
});

server.bind(8443).with_signals(); // Standard HTTPS port
server.start();
server.wait_for_signal();
```

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

### Pre-allocation example with glz::beve_peek_header

Source: https://github.com/stephenberry/glaze/blob/main/docs/binary.md

Shows how to peek at a buffer to get the element count and reserve space before deserializing, avoiding reallocation.

```c++
// Receive BEVE data from network/file
std::string buffer = receive_beve_data();

// Peek to get element count
auto header = glz::beve_peek_header(buffer);
if (!header) {
   handle_error(header.error());
   return;
}

// Pre-allocate based on peeked count
std::vector<double> values;
values.reserve(header->count);

// Now deserialize - vector won't need to reallocate
glz::read_beve(values, buffer);
```

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

### Complete Working Example: CMakeLists.txt

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

CMake configuration for the complete example. Fetches Glaze and ASIO via FetchContent, sets C++23, and links required libraries. Includes Windows-specific ws2_32 and MSVC preprocessor flags.

```cmake
# CMakeLists.txt
cmake_minimum_required(VERSION 3.31)
project(hello_server LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)

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

FetchContent_Declare(
  asio
  GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
  GIT_TAG asio-1-36-0
  GIT_SHALLOW TRUE
)

FetchContent_MakeAvailable(glaze asio)

add_executable(hello_server main.cpp)
target_link_libraries(hello_server PRIVATE glaze::glaze)
target_include_directories(hello_server PRIVATE ${asio_SOURCE_DIR}/asio/include)

if(WIN32)
    target_link_libraries(hello_server PRIVATE ws2_32)
endif()

if(MSVC)
    target_compile_options(hello_server PRIVATE /Zc:preprocessor)
endif()
```

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

### Quick CORS Setup with glz::http_server

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/advanced-networking.md

Enables CORS with default settings (allows all origins) and starts the server on port 8080. Blocks until Ctrl+C is received.

```cpp
#include "glaze/net/http_server.hpp"

glz::http_server server;

// Enable CORS with default settings (allows all origins)
server.enable_cors();

// Good for development, allows all origins and methods
server.bind(8080).with_signals();
server.start();
server.wait_for_signal(); // Block until Ctrl+C
```

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

### Ubuntu/Debian Manual Install Glaze

Source: https://github.com/stephenberry/glaze/blob/main/docs/installation.md

Installs dependencies, clones the repository, and builds/installs Glaze manually.

```bash
# Install dependencies
sudo apt-get update
sudo apt-get install build-essential cmake git

# Clone and install
git clone https://github.com/stephenberry/glaze.git
cd glaze
mkdir build && cd build
cmake ..
sudo make install
```

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

### CustomService Methods

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/rest-registry.md

Example service methods demonstrating automatic HTTP mapping: methods with parameters become POST endpoints, methods without parameters become GET endpoints.

```APIDOC
## [POST] /getUserStats

### Description
Retrieves user statistics. This method takes a StatsRequest object parameter and is mapped to a POST endpoint.

### Method
POST

### Endpoint
/getUserStats

### Parameters
#### Request Body
- **req** (StatsRequest) - Required - Request object for user statistics.

### Request Example
```json
{
  "query": "example",
  "limit": 10,
  "offset": 0
}
```

### Response
#### Success Response (200)
- **UserStats** (object) - User statistics.

#### Response Example
```json
{
  "total_count": 100,
  "has_more": true
}
```

## [POST] /searchUsers

### Description
Searches for users. This method takes a SearchQuery object parameter and is mapped to a POST endpoint.

### Method
POST

### Endpoint
/searchUsers

### Parameters
#### Request Body
- **query** (SearchQuery) - Required - Search query object.

### Request Example
```json
{
  "query": "john",
  "limit": 10,
  "offset": 0
}
```

### Response
#### Success Response (200)
- **SearchResults** (object) - Search results.

#### Response Example
```json
{
  "books": [],
  "total_count": 0,
  "has_more": false
}
```

## [POST] /validateUser

### Description
Validates a user. This method takes a User object parameter and is mapped to a POST endpoint.

### Method
POST

### Endpoint
/validateUser

### Parameters
#### Request Body
- **user** (User) - Required - User object to validate.

### Request Example
```json
{
  "id": 1,
  "name": "John Doe"
}
```

### Response
#### Success Response (200)
- **ValidationResult** (object) - Validation result.

#### Response Example
```json
{
  "valid": true
}
```

## [GET] /getAllActiveUsers

### Description
Retrieves all active users. This method has no parameters and is mapped to a GET endpoint.

### Method
GET

### Endpoint
/getAllActiveUsers

### Parameters
None

### Response
#### Success Response (200)
- **users** (array of User) - List of active users.

#### Response Example
```json
[
  {
    "id": 1,
    "name": "John Doe"
  }
]
```

## [GET] /getServerStatus

### Description
Retrieves server status. This method has no parameters and is mapped to a GET endpoint.

### Method
GET

### Endpoint
/getServerStatus

### Parameters
None

### Response
#### Success Response (200)
- **ServerStatus** (object) - Server status.

#### Response Example
```json
{
  "status": "ok"
}
```

## [GET] /getVersion

### Description
Retrieves the version. This method has no parameters and is mapped to a GET endpoint.

### Method
GET

### Endpoint
/getVersion

### Parameters
None

### Response
#### Success Response (200)
- **version** (string) - Version string.

#### Response Example
```json
{
  "version": "1.0.0"
}

```

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

### WebSocket Chat Server with Glaze

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/http-examples.md

Complete C++ example of a WebSocket chat server using Glaze. It sets up a WebSocket server, handles open/message/close/error events, mounts the WebSocket at /ws, serves an HTML chat client at /, provides a /api/stats endpoint, enables CORS, and starts the server with signal handling for graceful shutdown.

```cpp
int main() {
    glz::http_server server;
    ChatRoom chat_room;
    
    // Create WebSocket server
    auto ws_server = std::make_shared<glz::websocket_server>();
    
    // Handle new connections
    ws_server->on_open([&chat_room](std::shared_ptr<glz::websocket_connection> conn, const glz::request& req) {
        // Extract username from query parameters or headers
        std::string username = "User" + std::to_string(std::rand() % 1000);
        
        // In a real app, you'd extract this from authentication
        if (auto name = req.headers.first_value("x-username")) {
            username = *name;
        }
        
        std::cout << "WebSocket connection from " << conn->remote_address() << " (username: " << username << ")" << std::endl;
        
        chat_room.add_connection(conn, username);
        
        // Send welcome message
        conn->send_text(R"({"username":"System","message":"Welcome to the chat!","type":"system"})");
    });
    
    // Handle incoming messages
    ws_server->on_message([&chat_room](std::shared_ptr<glz::websocket_connection> conn, std::string_view message, glz::ws_opcode opcode) {
        if (opcode == glz::ws_opcode::text) {
            chat_room.handle_message(conn, std::string(message));
        }
    });
    
    // Handle connection close
    ws_server->on_close([&chat_room](std::shared_ptr<glz::websocket_connection> conn) {
        chat_room.remove_connection(conn);
    });
    
    // Handle errors
    ws_server->on_error([](std::shared_ptr<glz::websocket_connection> conn, std::error_code ec) {
        std::cerr << "WebSocket error: " << ec.message() << std::endl;
    });
    
    // Mount WebSocket
    server.websocket("/ws", ws_server);
    
    // HTTP endpoints
    server.get("/", [](const glz::request&, glz::response& res) {
        res.content_type("text/html").body(R"(
<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Chat</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        #messages { border: 1px solid #ccc; height: 400px; overflow-y: scroll; padding: 10px; margin-bottom: 10px; }
        #messageInput { width: 70%; padding: 5px; }
        #sendButton { padding: 5px 10px; }
        .message { margin-bottom: 5px; }
        .system { color: #666; font-style: italic; }
        .join { color: #008000; }
        .leave { color: #ff0000; }
    </style>
</head>
<body>
    <h1>WebSocket Chat</h1>
    <div id="messages"></div>
    <input type="text" id="messageInput" placeholder="Type your message...">
    <button id="sendButton">Send</button>
    
    <script>
        const ws = new WebSocket('ws://localhost:8080/ws');
        const messages = document.getElementById('messages');
        const messageInput = document.getElementById('messageInput');
        const sendButton = document.getElementById('sendButton');
        
        ws.onopen = function() {
            addMessage('Connected to chat server', 'system');
        };
        
        ws.onmessage = function(event) {
            const msg = JSON.parse(event.data);
            addMessage(msg.username + ': ' + msg.message, msg.type);
        };
        
        ws.onclose = function() {
            addMessage('Disconnected from chat server', 'system');
        };
        
        function addMessage(text, type) {
            const div = document.createElement('div');
            div.className = 'message ' + type;
            div.textContent = new Date().toLocaleTimeString() + ' - ' + text;
            messages.appendChild(div);
            messages.scrollTop = messages.scrollHeight;
        }
        
        function sendMessage() {
            const message = messageInput.value.trim();
            if (message && ws.readyState === WebSocket.OPEN) {
                ws.send(message);
                messageInput.value = '';
            }
        }
        
        sendButton.onclick = sendMessage;
        messageInput.onkeypress = function(e) {
            if (e.key === 'Enter') {
                sendMessage();
            }
        };
    </script>
</body>
</html>
        )");
    });
    
    // Chat stats endpoint
    server.get("/api/stats", [&chat_room](const glz::request&, glz::response& res) {
        res.json({
            {"users_online", chat_room.get_user_count()},
            {"server_time", std::time(nullptr)}
        });
    });
    
    server.enable_cors();
    
    std::cout << "Chat server running on http://localhost:8080" << std::endl;
    std::cout << "WebSocket endpoint: ws://localhost:8080/ws" << std::endl;
    std::cout << "Press Ctrl+C to gracefully shut down the server" << std::endl;
    
    server.bind(8080)
          .with_signals();  // Enable signal handling for graceful shutdown
    
    server.start();
    
    // Wait for shutdown signal (blocks until server stops)
    server.wait_for_signal();
    
    std::cout << "Server shut down successfully" << std::endl;
    return 0;
}
```

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

### Configure thread pool with start()

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/http-server.md

Shows how to start the server with default thread count (hardware concurrency, minimum 1), with a specific number of threads, or without worker threads (pass 0) for external io_context management.

```cpp
// Start with default thread count (hardware concurrency, minimum 1)
server.start();   // Uses std::thread::hardware_concurrency(), minimum 1 thread

// Start with specific number of threads
server.start(4);  // 4 worker threads

// Start without creating worker threads (for external io_context management)
server.start(0);  // No worker threads - caller manages io_context::run()
```

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

### Start server with signal handling

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/http-server.md

Creates a glz::http_server, configures a route, binds to port 8080 with signal handling enabled, starts the server, and waits for a shutdown signal.

```cpp
// Simple server with signal handling
int main() {
    glz::http_server server;

    // Configure routes
    server.get("/api/hello", [](const glz::request&, glz::response& res) {
        res.json({{"message", "Hello, World!"}});
    });

    // Bind and enable signal handling
    server.bind(8080)
          .with_signals();

    // Start server
    server.start();

    // Wait for shutdown signal
    server.wait_for_signal();

    return 0;
}
```

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

### Examples of expect() assertions

Source: https://github.com/stephenberry/glaze/blob/main/tests/ut-guide.md

Several examples of using expect() to verify conditions, including equality, emptiness, comparison, and negation.

```cpp
expect(result == expected) << "Result should equal expected value\n";
expect(vec.empty()) << "Vector should be empty after clear\n";
expect(a < b) << "a should be less than b\n";
expect(not is_empty) << "Container should not be empty\n";
```

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

### Basic YAML anchors and aliases with merge key example

Source: https://github.com/stephenberry/glaze/blob/main/docs/yaml.md

Shows basic YAML anchor and alias usage, including a merge key example that is not yet supported. Demonstrates defining defaults with an anchor and referencing scalar values via aliases.

```yaml
defaults: &defaults
  timeout: 30
  retries: 3

production:
  host: prod.example.com
  <<: *defaults  # Not yet supported (merge keys)

# Simple scalar anchors and aliases:
database_host: &db_host db.example.com
primary: *db_host
replica: *db_host

```

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

### Install Boost.Asio via package manager

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

Commands to install Boost.Asio on macOS, Ubuntu/Debian, Arch Linux, vcpkg, and Conan. Use this if you already use Boost in your project.

```bash
# macOS (Homebrew)
brew install boost

# Ubuntu/Debian
sudo apt-get install libboost-system-dev

# Arch Linux
sudo pacman -S boost

# vcpkg
vcpkg install boost-asio

# Conan
conan install boost/1.83.0@
```

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

### Conan Command Line Installation

Source: https://github.com/stephenberry/glaze/blob/main/docs/installation.md

Installs dependencies and builds the project using Conan presets. Run these commands in the project root.

```bash
conan install . --build=missing
cmake --preset conan-default
cmake --build --preset conan-release
```

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

### Install OpenSSL on Ubuntu/Debian, macOS, and Windows

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/tls-support.md

Commands to install OpenSSL on different operating systems. For Ubuntu/Debian, use apt-get. For macOS with Homebrew, install openssl and set PKG_CONFIG_PATH. For Windows, use vcpkg.

```bash
# On Ubuntu/Debian
sudo apt-get install libssl-dev

# On macOS with Homebrew
brew install openssl
export PKG_CONFIG_PATH="/opt/homebrew/lib/pkgconfig"

# On Windows
vcpkg install openssl
```

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

### HTTP PATCH Client Integration Example

Source: https://github.com/stephenberry/glaze/blob/main/docs/design/json_merge_patch_rfc7386.md

Example of integrating merge patch with an HTTP client for application/merge-patch+json content type.

```cpp
// Example HTTP client integration
auto response = client.patch(url, merge_patch_document, {
   {"Content-Type", "application/merge-patch+json"}
});
```

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

### rfc7386 appendix a example

Source: https://github.com/stephenberry/glaze/blob/main/docs/design/json_merge_patch_rfc7386.md

A complete example from RFC 7386 Appendix A, showing how to apply a merge patch to a JSON document and verify the expected result.

```cpp
// RFC 7386 Appendix A example
"rfc7386 appendix a example"_test = [] {
   auto target = glz::read_json<glz::generic>(R"({
      "title": "Goodbye!",
      "author": {
         "givenName": "John",
         "familyName": "Doe"
      },
      "tags": ["example", "sample"],
      "content": "This will be unchanged"
   })");

   auto patch = glz::read_json<glz::generic>(R"({
      "title": "Hello!",
      "phoneNumber": "+01-123-456-7890",
      "author": {
         "familyName": null
      },
      "tags": ["example"]
   })");

   auto ec = glz::merge_patch(*target, *patch);
   expect(!ec);

   auto expected = glz::read_json<glz::generic>(R"({
      "title": "Hello!",
      "author": {
         "givenName": "John"
      },
      "tags": ["example"],
      "content": "This will be unchanged",
      "phoneNumber": "+01-123-456-7890"
   })");
   expect(glz::equal(*target, *expected));
};
```

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

### Basic Paths: get<int> and get<std::string>

Source: https://github.com/stephenberry/glaze/blob/main/docs/advanced-api-usage.md

Shows how to retrieve scalar members using JSON Pointer paths like '/port' and '/host'.

```c++
struct config {
  int port = 8080;
  std::string host = "localhost";
  std::vector<std::string> endpoints = {"api", "health", "metrics"};
};

auto* port = api->get<int>("/port");
auto* host = api->get<std::string>("/host");
```

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

### Install standalone ASIO via package manager

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

Commands to install standalone ASIO on macOS, Ubuntu/Debian, Arch Linux, vcpkg, and Conan. Standalone ASIO is header-only and preferred by Glaze.

```bash
# macOS (Homebrew)
brew install asio

# Ubuntu/Debian
sudo apt-get install libasio-dev

# Arch Linux
sudo pacman -S asio

# vcpkg
vcpkg install asio

# Conan
conan install asio/1.28.0@
```

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

### Complete CMakeLists.txt Example for Glaze Project

Source: https://github.com/stephenberry/glaze/blob/main/docs/installation.md

Sets up a CMake project using FetchContent to download Glaze from GitHub, links the glaze::glaze target, and applies the MSVC-specific /Zc:preprocessor flag when building with MSVC.

```cmake
cmake_minimum_required(VERSION 3.31)
project(MyGlazeProject LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

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

add_executable(myapp main.cpp)
target_link_libraries(myapp PRIVATE glaze::glaze)

# MSVC specific flag
if(MSVC)
    target_compile_options(myapp PRIVATE /Zc:preprocessor)
endif()
```

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

### Skip keys by prefix using starts_with

Source: https://github.com/stephenberry/glaze/blob/main/docs/skip-keys.md

Defines a struct with fields starting with 'temp_' and a glz::meta specialization that skips any key starting with 'temp_'. The usage example shows the JSON output without the temp_data field.

```cpp
struct prefixed_skipped_t {
    std::string user_id{};
    std::string user_name{};
    std::string temp_data{};
};

template <>
struct glz::meta<prefixed_skipped_t> {
    static constexpr bool skip(const std::string_view key, const meta_context&) { 
        return key.starts_with("temp_"); // Skip keys starting with "temp_"
    }
};
```

```cpp
prefixed_skipped_t obj{"123", "Alice", "temporary value"};
std::string buffer{};

// Writing JSON
glz::write_json(obj, buffer);
// Output: {"user_id":"123","user_name":"Alice"}
```

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

### Basic WebSocket Server Setup

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/advanced-networking.md

Creates a WebSocket server with handlers for open, message, close, and error events, then mounts it on an HTTP server. Supports parameterized routes like /rooms/:room/ws, with captured values available in request.params inside on_open.

```cpp
#include "glaze/net/websocket_connection.hpp"

// Create WebSocket server
auto ws_server = std::make_shared<glz::websocket_server>();

// Handle new connections
ws_server->on_open([](std::shared_ptr<glz::websocket_connection> conn, const glz::request& req) {
    std::cout << "WebSocket connection opened from " << conn->remote_address() << std::endl;
    conn->send_text("Welcome to the WebSocket server!");
});

// Handle incoming messages
ws_server->on_message([](std::shared_ptr<glz::websocket_connection> conn, std::string_view message, glz::ws_opcode opcode) {
    if (opcode == glz::ws_opcode::text) {
        std::cout << "Received: " << message << std::endl;
        
        // Echo message back
        conn->send_text("Echo: " + std::string(message));
    }
});

// Handle connection close
ws_server->on_close([](std::shared_ptr<glz::websocket_connection> conn) {
    std::cout << "WebSocket connection closed" << std::endl;
});

// Handle errors
ws_server->on_error([](std::shared_ptr<glz::websocket_connection> conn, std::error_code ec) {
    std::cerr << "WebSocket error: " << ec.message() << std::endl;
});

// Mount WebSocket on HTTP server
glz::http_server server;
server.websocket("/ws", ws_server);

server.bind(8080).with_signals();
server.start();
server.wait_for_signal();
```

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

### Get targeted value with glz::get_as_json

Source: https://github.com/stephenberry/glaze/blob/main/docs/json-pointer-syntax.md

Extracts a value from a JSON buffer using a JSON pointer. The example retrieves a double from a nested object.

```c++
std::string s = R"({"obj":{"x":5.5}})";
auto z = glz::get_as_json<double, "/obj/x">(s);
expect(z == 5.5);
```

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

### Complete Example with ASIO (FetchContent)

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

A full CMake project that fetches Glaze and standalone ASIO via FetchContent, sets C++23, and links glaze::glaze. It adds the ASIO include directory and enables the MSVC preprocessor flag /Zc:preprocessor.

```cmake
cmake_minimum_required(VERSION 3.31)
project(MyNetworkingApp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)

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

# Fetch standalone ASIO
FetchContent_Declare(
  asio
  GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
  GIT_TAG asio-1-36-0
  GIT_SHALLOW TRUE
)
FetchContent_MakeAvailable(asio)

add_executable(myapp main.cpp)
target_link_libraries(myapp PRIVATE glaze::glaze)
target_include_directories(myapp PRIVATE ${asio_SOURCE_DIR}/asio/include)

# MSVC specific
if(MSVC)
    target_compile_options(myapp PRIVATE /Zc:preprocessor)
endif()
```

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

### Basic WebSocket client usage with event handlers

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/websocket-client.md

Shows how to create a glz::websocket_client, set up event handlers for open, message, close, and error events, connect to a WebSocket server, and run the io_context. Requires ASIO; OpenSSL is needed for WSS connections.

```cpp
#include "glaze/net/websocket_client.hpp"

int main() {
    glz::websocket_client client;

    // Setup event handlers
    client.on_open([]() {
        std::cout << "Connected to WebSocket server!" << std::endl;
    });

    client.on_message([](std::string_view message, glz::ws_opcode opcode) {
        if (opcode == glz::ws_opcode::text) {
            std::cout << "Received: " << message << std::endl;
        }
    });

    client.on_close([](glz::ws_close_code code, std::string_view reason) {
        std::cout << "Connection closed with code: " << static_cast<int>(code);
        if (!reason.empty()) {
            std::cout << ", reason: " << reason;
        }
        std::cout << std::endl;
    });

    client.on_error([](std::error_code ec) {
        std::cerr << "Error: " << ec.message() << std::endl;
    });

    // Connect to WebSocket server
    client.connect("ws://localhost:8080/ws");

    // Run the io_context (blocks until connection is closed)
    client.run();

    return 0;
}
```

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

### Recommended: Link glaze::asio with glaze_setup_asio()

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

Use this CMake snippet to set up Glaze's ASIO backend. It selects Boost, standalone, or bundled Asio and defines GLZ_USE_BOOST_ASIO when Boost is chosen, keeping the header and CMake in sync.

```cmake
find_package(glaze CONFIG REQUIRED)   # or FetchContent_MakeAvailable(glaze)

glaze_setup_asio()                    # picks Boost / standalone / bundled Asio

add_executable(myapp main.cpp)
target_link_libraries(myapp PRIVATE glaze::glaze glaze::asio)
```

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

### BookService Methods

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/rest-registry.md

Example service methods that map to HTTP endpoints: getAllBooks (GET), getBookById (POST), createBook (POST), updateBook (PUT), deleteBook (POST with 204 response).

```APIDOC
## [GET] /getAllBooks

### Description
Retrieves all books. This method has no parameters and is mapped to a GET endpoint.

### Method
GET

### Endpoint
/getAllBooks

### Parameters
None

### Response
#### Success Response (200)
- **books** (array of Book) - List of all books

#### Response Example
```json
[
  {
    "id": 1,
    "title": "Example Book",
    "author": "Author Name",
    "isbn": "1234567890",
    "year": 2023
  }
]
```

## [POST] /getBookById

### Description
Retrieves a book by its ID. This method takes a single integer parameter and is mapped to a POST endpoint with a JSON body.

### Method
POST

### Endpoint
/getBookById

### Parameters
#### Request Body
- **id** (int) - Required - The ID of the book to retrieve.

### Request Example
```json
{
  "id": 1
}
```

### Response
#### Success Response (200)
- **Book** (object) - The requested book.

#### Response Example
```json
{
  "id": 1,
  "title": "Example Book",
  "author": "Author Name",
  "isbn": "1234567890",
  "year": 2023
}
```

## [POST] /createBook

### Description
Creates a new book. This method takes a Book object parameter and is mapped to a POST endpoint with an object body.

### Method
POST

### Endpoint
/createBook

### Parameters
#### Request Body
- **id** (int) - Required - Book ID.
- **title** (string) - Required - Book title.
- **author** (string) - Required - Book author.
- **isbn** (string) - Required - ISBN.
- **year** (int) - Required - Publication year.

### Request Example
```json
{
  "id": 2,
  "title": "New Book",
  "author": "New Author",
  "isbn": "0987654321",
  "year": 2024
}
```

### Response
#### Success Response (200)
- **Book** (object) - The created book.

#### Response Example
```json
{
  "id": 2,
  "title": "New Book",
  "author": "New Author",
  "isbn": "0987654321",
  "year": 2024
}
```

## [PUT] /updateBook

### Description
Updates an existing book. This method takes a BookUpdate object parameter and is mapped to a PUT endpoint.

### Method
PUT

### Endpoint
/updateBook

### Parameters
#### Request Body
- **id** (int) - Required - ID of the book to update.
- **title** (string) - Required - New title.
- **author** (string) - Required - New author.

### Request Example
```json
{
  "id": 1,
  "title": "Updated Title",
  "author": "Updated Author"
}
```

### Response
#### Success Response (200)
- **Book** (object) - The updated book.

#### Response Example
```json
{
  "id": 1,
  "title": "Updated Title",
  "author": "Updated Author",
  "isbn": "1234567890",
  "year": 2023
}
```

## [POST] /deleteBook

### Description
Deletes a book by ID. This method takes an integer parameter and returns void, mapped to a POST endpoint with a 204 No Content response.

### Method
POST

### Endpoint
/deleteBook

### Parameters
#### Request Body
- **id** (int) - Required - The ID of the book to delete.

### Request Example
```json
{
  "id": 1
}
```

### Response
#### Success Response (204)
No content.

```

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

### repe_plugin_init (Optional)

Source: https://github.com/stephenberry/glaze/blob/main/docs/rpc/repe-plugin.md

Initializes the plugin. This is optional and may be NULL if not needed. Returns a repe_result indicating success or failure.

```APIDOC
## repe_plugin_init (Optional)

### Description
Initializes the plugin. This is optional and may be NULL if not needed. Returns a repe_result indicating success or failure.

### Method
C function

### Endpoint
N/A (C function)

### Parameters
None

### Request Example
N/A

### Response
#### Success Response
- **repe_result** - REPE_OK (0) on success, REPE_ERROR_INIT_FAILED (1) on failure, or REPE_ERROR_ALREADY_INITIALIZED (2) if already initialized.

#### Response Example
```c
repe_result result = repe_plugin_init();
```
```

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

### glz::get_sv_json - Get std::string_view to Raw JSON

Source: https://github.com/stephenberry/glaze/blob/main/docs/struct-json-pointer.md

Returns a std::string_view to the raw JSON at a path without parsing. The example shows retrieving a JSON array as a string view.

```c++
std::string json = R"({"data": {"values": [1, 2, 3]}})";

auto view = glz::get_sv_json<"/data/values">(json);
// view == "[1, 2, 3]"
```

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

### Retrieve detailed error messages with last_error()

Source: https://github.com/stephenberry/glaze/blob/main/docs/glaze-interfaces.md

Use the last_error() method to get detailed error messages after a failed operation. This example shows checking the return value and printing the error message.

```c++
auto* x = io->get<int>("/wrong_path");
if (!x) {
  std::cout << "Error: " << io->last_error() << "\n";
}

auto result = io->call<int>("/wrong_type");
if (!result) {
  std::cout << "Error: " << io->last_error() << "\n";
}
```

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

### repe_plugin_init

Source: https://github.com/stephenberry/glaze/blob/main/docs/rpc/repe-plugin.md

Initializes the plugin. This function is optional and can be used to perform setup before the plugin is used.

```APIDOC
## repe_plugin_init

### Description
Initializes the plugin. This is an optional function that can be used for setup.

### Method
C function

### Signature
`repe_plugin_init()`

### Parameters
None

### Return Value
None
```

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

### Wrap-around behavior example

Source: https://github.com/stephenberry/glaze/blob/main/docs/lazy-json.md

Demonstrates that accessing a key earlier in the document causes the parser to wrap around, scanning from the current position to the end and then from the start to the key. This works correctly but is slower than sequential access.

```cpp
doc["c"].get<int64_t>();  // Position now after "c"
doc["a"].get<int64_t>();  // Wraps: scans from "c" to end, then start to "a"
```

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

### Using Boost.Asio (find_package Boost)

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/asio-setup.md

Links Glaze with Boost.Asio by finding the Boost system component and linking Boost::system alongside glaze::glaze.

```cmake
find_package(Boost REQUIRED COMPONENTS system)
target_link_libraries(myapp PRIVATE glaze::glaze Boost::system)
```

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

### P2996 reflection primitives example

Source: https://github.com/stephenberry/glaze/blob/main/docs/p2996-reflection.md

Shows how to reflect on a type, get non-static data members, retrieve member names, and splice to access a member. Uses `^^Person`, `std::meta::nonstatic_data_members_of`, `std::meta::identifier_of`, and `[:members[0]:]`.

```cpp
// Reflect on a type to get meta-info
constexpr auto type_info = ^^Person;

// Get all non-static data members
constexpr auto members = std::meta::nonstatic_data_members_of(
    ^^Person,
    std::meta::access_context::unchecked()
);

// Get member name
constexpr auto name = std::meta::identifier_of(members[0]);
// name == "name"

// Splice to access member
Person p;
p.[:members[0]:] = "Alice";  // Sets p.name
```

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

### Connect and run WebSocket client

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/websocket-client.md

Connect to a WebSocket server and run the client. This is the core operation for the echo client example.

```cpp
client.connect("ws://localhost:8080/ws");
client.run();

return 0;
}
```

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

### Access unwrapped pointer values through the API

Source: https://github.com/stephenberry/glaze/blob/main/docs/glaze-interfaces.md

Shows how to access the pointed-to values through the Glaze API. The get<T> method returns a pointer to the unwrapped value, not a pointer to the pointer. The example prints the values: 7, 5.5, and "hello".

```c++
auto io = (*iface)["my_api"]();

// Access through raw pointer - returns pointer to the int, not pointer to pointer
auto* x = io->get<int>("/x_ptr");
if (x) {
  std::cout << *x << "\n";  // prints 7
}

// Access through unique_ptr - returns pointer to the double
auto* y = io->get<double>("/uptr");
if (y) {
  std::cout << *y << "\n";  // prints 5.5
}

// Access through shared_ptr - returns pointer to the string
auto* s = io->get<std::string>("/sptr");
if (s) {
  std::cout << *s << "\n";  // prints "hello"
}
```

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

### BSON quick start: write and read a struct

Source: https://github.com/stephenberry/glaze/blob/main/docs/bson.md

Shows how to serialize a struct to BSON using glz::write_bson and read it back with glz::read_bson. The write function returns an error_ctx; success is the falsy case. The read function returns an error_ctx; on error, use glz::format_error to get a message.

```cpp
#include "glaze/bson.hpp"

struct point
{
   double x{};
   double y{};
};

point p{.x = 4.2, .y = 1.3};

// Write into a std::string (or std::vector<char> / std::vector<std::byte>)
auto encoded = glz::write_bson(p);
if (!encoded) {
   // glz::format_error(encoded.error()) for a message
}

// Read the buffer back
point decoded{};
auto ec = glz::read_bson(decoded, std::string_view{encoded.value()});
if (ec) {
   const auto message = glz::format_error(ec, encoded.value());
}
```

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

### Set client max_response_body_size and handle oversized response

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/body-size-limits.md

Sets the maximum response body size to 10 MB on a `glz::http_client` instance. Responses exceeding the limit return `glz::http_client_error::response_too_large`. The example shows how to check for this error after a GET request. Set to 0 for no limit; default is 100 MB.

```cpp
glz::http_client client;
client.max_response_body_size(10 * 1024 * 1024); // 10 MB limit

auto result = client.get("http://example.com/large-file");
if (!result && result.error() == glz::http_client_error::response_too_large) {
   // handle oversized response
}
```

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

### Custom API Implementation Inheriting from glz::api

Source: https://github.com/stephenberry/glaze/blob/main/docs/advanced-api-usage.md

Shows how to create a custom API implementation by inheriting from glz::api and overriding virtual methods like get, contains, read, write, caller, and get_fn. The example includes a std::map for data and demonstrates custom logic for path handling and type hashing.

```c++
#include "glaze/api/api.hpp"

struct custom_api : glz::api {
  // Your custom data
  std::map<std::string, int> data;

  // Override the virtual methods
  std::pair<void*, glz::hash_t> get(const sv path) noexcept override {
    // Custom implementation
    if (path == "/count") {
      static constexpr auto hash = glz::hash<int>();
      return {&data["count"], hash};
    }
    return {nullptr, {}};
  }

  bool contains(const sv path) noexcept override {
    return path == "/count";
  }

  bool read(const uint32_t format, const sv path, const sv data) noexcept override {
    // Custom deserialization logic
    return true;
  }

  bool write(const uint32_t format, const sv path, std::string& data) noexcept override {
    // Custom serialization logic
    return true;
  }

protected:
  bool caller(const sv path, const glz::hash_t type_hash, void*& ret,
              std::span<void*> args) noexcept override {
    // Custom function calling logic
    return false;
  }

  std::unique_ptr<void, void (*)(void*)> get_fn(const sv path,
                                                 const glz::hash_t type_hash) noexcept override {
    // Custom function retrieval logic
    return {nullptr, nullptr};
  }
};
```

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

### Static Routes

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/http-router.md

Shows how to register static routes using the router's get method. Includes simple and nested static paths.

```cpp
glz::http_router router;

// Simple static routes
router.get("/", home_handler);
router.get("/about", about_handler);
router.get("/contact", contact_handler);

// Nested static routes
router.get("/api/v1/status", status_handler);
router.get("/api/v1/health", health_handler);
```

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

### Configure CA certificates and make GET request

Source: https://github.com/stephenberry/glaze/blob/main/docs/networking/http-client.md

Shows how to call configure_system_ca_certificates with an explicit bundle path, handle the error case, and then perform a GET request. The fallback to OpenSSL default paths always succeeds even if empty, so use add_ca_certificate_file for certainty.

```cpp
glz::http_client client;

if (auto result = client.configure_system_ca_certificates("/path/to/cert.pem"); !result) {
    std::cerr << "Failed to configure CA trust roots: " << result.error().message() << '\n';
    return;
}

auto response = client.get("https://example.com");
```

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

### Access array elements by index with glz::lazy_json

Source: https://github.com/stephenberry/glaze/blob/main/docs/lazy-json.md

Shows how to access specific array elements using bracket notation and the get<int64_t>() method. The example parses a JSON string, accesses doc["items"][0]["value"] and doc["items"][2]["id"], and prints the results if the values are valid.

```cpp
std::string json = R"({
   "items": [
      {"id": 1, "value": 100},
      {"id": 2, "value": 200},
      {"id": 3, "value": 300}
   ]
})";

auto result = glz::lazy_json(json);
if (result) {
    auto& doc = *result;

    // Access specific array element
    auto first_value = doc["items"][0]["value"].get<int64_t>();
    auto third_id = doc["items"][2]["id"].get<int64_t>();

    if (first_value && third_id) {
        std::cout << "First value: " << *first_value << "\n";
        std::cout << "Third id: " << *third_id << "\n";
    }
}
```

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

### CMakeLists.txt for the client

Source: https://github.com/stephenberry/glaze/blob/main/docs/building-shared-libraries.md

Builds the client executable, links against Glaze, and adds a dependency on the my_library target.

```cmake
project(client)

add_executable(${PROJECT_NAME} client.cpp)

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

# Make sure the client depends on the library being built
add_dependencies(${PROJECT_NAME} my_library)
```
Tokens:
Raw