C++ APISession methods
delete_session_value
Removes a key-value entry from temporary session-scoped storage.
delete_session_value(std::string key) removes a value under key from the
current session cache and returns blaze::status.
Function variants
blaze::status delete_session_value(std::string key);
blaze::status delete_session_value(std::string key, std::error_code& ec) noexcept;
void async_delete_session_value(std::string key, std::function<void(std::error_code, blaze::status)> callback);
blaze::coro::awaitable_result<blaze::status> co_delete_session_value(std::string key);Status vs error
The returned blaze::status is the API result. std::error_code and
std::system_error are used for transport/runtime failures only.
Parameters
Prop
Type
Result
blaze::statusUse direct comparison, for example:
if (status == blaze::status::ok) {
// success
}Behavior notes
- Call
delete_session_valueonly after successfulconnectandinitialize. - This removes data from the same volatile per-session cache used by
set_session_valueandget_session_value. - Deletion affects only the current session and does not touch values stored in other sessions.
- If the key does not exist or its value already expired, the operation returns
blaze::status::store_value_not_found. - After a successful delete,
get_session_value(key)returnsblaze::status::store_value_not_founduntil a new value is written under the same key.
Example
Compilation note
Synchronous and Asynchronous examples compile in the same form from C++17
to C++26.
#include "blazeauth/api/api.hpp"
#include <chrono>
#include <iostream>
#include <string>
#include <system_error>
void print_error_code(const std::string& context, const std::error_code& ec) {
std::cout << context << ": " << ec.message() << " ("
<< ec.value() << " : " << ec.category().name() << ")\n";
}
std::string read_line(const std::string& label) {
std::string value;
std::cout << label << ": ";
std::getline(std::cin, value);
return value;
}
void print_status(const std::string& context, blaze::status status) {
std::cout << context << ": "
<< static_cast<unsigned int>(status)
<< " (" << blaze::to_string(status) << ")\n";
}
int main() {
const std::string websocket_api_key = read_line("Websocket API key");
const std::string client_id = read_line("Client ID");
const std::string key = read_line("Session key");
const std::string value_content = read_line("Value to pre-store");
blaze::session session;
try {
const blaze::api_server server = session.connect();
std::cout << "Connected to server location: " << server.location << '\n';
const blaze::application app = session.initialize(websocket_api_key, client_id);
if (!app.good()) {
print_status("Initialize returned status", app.status);
return 1;
}
const blaze::status set_status = session.set_session_value(key, value_content, std::chrono::minutes(10));
if (set_status != blaze::status::ok) {
print_status("Set-session-value returned status", set_status);
return 1;
}
const blaze::status delete_status = session.delete_session_value(key);
if (delete_status != blaze::status::ok) {
print_status("Delete-session-value returned status", delete_status);
return 1;
}
std::cout << "Session value deleted successfully\n";
session.shutdown();
} catch (const std::system_error& e) {
print_error_code("Delete-session-value failed", e.code());
return 1;
}
return 0;
}Delete-session-value statuses
| Value | Status | Returned when |
|---|---|---|
1 | ok | Value was removed successfully. |
700 | store_value_not_found | Key does not exist in the current session cache or value already expired. |
Connection-level shutdowns
Normal delete-session-value results are returned as
blaze::status. The websocket may still be closed by session-level guards:
| Close code | Meaning | When it can happen |
|---|---|---|
4200 | not_initialized | delete_session_value was called before a successful initialize. |
4201 | rate_limited | Session or IP rate limiting closed the websocket around this operation. |