.. _program_listing_file_SubscriptionRequest.cpp:

Program Listing for File SubscriptionRequest.cpp
================================================

|exhale_lsh| :ref:`Return to documentation for file <file_SubscriptionRequest.cpp>` (``SubscriptionRequest.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "netio3/SubscriptionRequest.hpp"
   
   #include <nlohmann/json.hpp>
   
   #include "netio3/NetioIssues.hpp"
   
   std::string netio3::SubscriptionRequest::to_json(const SubscriptionRequest& req) {
       nlohmann::json j;
       j["tag"] = req.tag;
       j["addr"] = req.addr;
       j["data_port"] = req.data_port;
       j["ack_port"] = req.ack_port;
       j["subscribe"] = static_cast<uint8_t>(req.subscribe);
       return j.dump();
   }
   
   netio3::SubscriptionRequest netio3::SubscriptionRequest::from_json(const std::string& req) {
       try {
           auto j = nlohmann::json::parse(req);
   
           // Validate all required fields exist before accessing them
           if (!j.contains("tag") || !j.contains("addr") || !j.contains("data_port") ||
               !j.contains("ack_port") || !j.contains("subscribe")) {
               throw SubscriptionParseError("Missing required field in subscription request", req);
           }
   
           // Convert with additional validation
           return SubscriptionRequest{
             .tag = j["tag"].get<std::uint64_t>(),
             .addr = j["addr"].get<std::string>(),
             .data_port = j["data_port"].get<std::uint16_t>(),
             .ack_port = j["ack_port"].get<std::uint16_t>(),
             .subscribe = static_cast<Sub>(j["subscribe"].get<uint8_t>()),
           };
       } catch (const nlohmann::json::parse_error& e) {
           throw SubscriptionParseError(std::format("Invalid JSON format: {}", e.what()), req);
       } catch (const nlohmann::json::type_error& e) {
           throw SubscriptionParseError(
             std::format("Type mismatch in subscription data: {}", e.what()), req);
       } catch (const nlohmann::json::out_of_range& e) {
           throw SubscriptionParseError(
             std::format("Missing field in subscription request: {}", e.what()), req);
       } catch (const nlohmann::json::exception& e) {
           throw SubscriptionParseError(std::format("JSON error: {}", e.what()), req);
       } catch (const std::exception& e) {
           throw SubscriptionParseError(
             std::format("Error processing subscription request: {}", e.what()), req);
       }
   }
   
   std::string netio3::SubscriptionAcknowledgement::to_json(const SubscriptionAcknowledgement& ack) {
       nlohmann::json j;
       j["tag"] = ack.tag;
       j["subscribe"] = static_cast<uint8_t>(ack.subscribe);
       return j.dump();
   }
   
   netio3::SubscriptionAcknowledgement netio3::SubscriptionAcknowledgement::from_json(const std::string& ack) {
       try {
           const auto j = nlohmann::json::parse(ack);
   
           // Validate all required fields exist before accessing them
           if (!j.contains("tag") || !j.contains("subscribe")) {
               throw SubscriptionParseError("Missing required field in subscription request", ack);
           }
   
           // Convert with additional validation
           return SubscriptionAcknowledgement{
             .tag = j["tag"].get<std::uint64_t>(),
             .subscribe = static_cast<SubscriptionRequest::Sub>(j["subscribe"].get<uint8_t>()),
           };
       } catch (const nlohmann::json::parse_error& e) {
           throw SubscriptionParseError(std::format("Invalid JSON format: {}", e.what()), ack);
       } catch (const nlohmann::json::type_error& e) {
           throw SubscriptionParseError(
             std::format("Type mismatch in subscription data: {}", e.what()), ack);
       } catch (const nlohmann::json::out_of_range& e) {
           throw SubscriptionParseError(
             std::format("Missing field in subscription acknowledgement: {}", e.what()), ack);
       } catch (const nlohmann::json::exception& e) {
           throw SubscriptionParseError(std::format("JSON error: {}", e.what()), ack);
       } catch (const std::exception& e) {
           throw SubscriptionParseError(
             std::format("Error processing subscription acknowledgement: {}", e.what()), ack);
       }
   }