QuicClientDemo Class Reference

Simple QUIC client demo. More...

Collaboration diagram for QuicClientDemo:

Public Member Functions
	QuicClientDemo (const std::string &server_host, unsigned short server_port)
bool	run ()

Private Member Functions
void	setup_callbacks ()
void	demo_send_default_stream ()
void	demo_multi_stream ()

Private Attributes
std::string	server_host_
unsigned short	server_port_
std::shared_ptr< core::messaging_quic_client >	client_
std::atomic< bool >	connected_
std::atomic< bool >	message_received_
std::mutex	mutex_
std::condition_variable	cv_

Detailed Description

Simple QUIC client demo.

Definition at line 41 of file quic_client_example.cpp.

Constructor & Destructor Documentation

QuicClientDemo()

QuicClientDemo::QuicClientDemo ( const std::string & server_host, unsigned short server_port )

inline

Definition at line 44 of file quic_client_example.cpp.

        : server_host_(server_host)
        , server_port_(server_port)
        , connected_(false)
        , message_received_(false)
    {
    }

Member Function Documentation

demo_multi_stream()

void QuicClientDemo::demo_multi_stream ( )

inlineprivate

Definition at line 184 of file quic_client_example.cpp.

    {
        std::cout << "\n=== Multi-Stream Demo ===" << std::endl;
 
        // Create a new bidirectional stream
        auto stream_result = client_->create_stream();
        if (stream_result.is_err())
        {
            std::cerr << "Failed to create stream: " << stream_result.error().message << std::endl;
            return;
        }
 
        uint64_t stream_id = stream_result.value();
        std::cout << "Created bidirectional stream: " << stream_id << std::endl;
 
        // Send data on the new stream
        std::string msg = "Hello from stream " + std::to_string(stream_id);
        std::vector<uint8_t> data(msg.begin(), msg.end());
 
        auto send_result = client_->send_on_stream(stream_id, std::move(data));
        if (send_result.is_ok())
        {
            std::cout << "Sent message on stream " << stream_id << std::endl;
        }
        else
        {
            std::cerr << "Failed to send: " << send_result.error().message << std::endl;
        }
 
        // Create a unidirectional stream
        auto uni_stream_result = client_->create_unidirectional_stream();
        if (uni_stream_result.is_ok())
        {
            uint64_t uni_stream_id = uni_stream_result.value();
            std::cout << "Created unidirectional stream: " << uni_stream_id << std::endl;
 
            std::string uni_msg = "Unidirectional message";
            std::vector<uint8_t> uni_data(uni_msg.begin(), uni_msg.end());
 
            // Send with FIN to close the stream after this message
            auto uni_send_result = client_->send_on_stream(uni_stream_id,
                                                            std::move(uni_data),
                                                            true /* fin */);
            if (uni_send_result.is_ok())
            {
                std::cout << "Sent message on unidirectional stream with FIN" << std::endl;
            }
        }
 
        // Close the bidirectional stream
        auto close_result = client_->close_stream(stream_id);
        if (close_result.is_ok())
        {
            std::cout << "Closed stream " << stream_id << std::endl;
        }
    }

References client_, kcenon::network::core::messaging_quic_client::close_stream(), kcenon::network::core::messaging_quic_client::create_stream(), kcenon::network::core::messaging_quic_client::create_unidirectional_stream(), and kcenon::network::core::messaging_quic_client::send_on_stream().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

demo_send_default_stream()

void QuicClientDemo::demo_send_default_stream ( )

inlineprivate

Definition at line 156 of file quic_client_example.cpp.

    {
        std::cout << "\n=== Sending on Default Stream ===" << std::endl;
 
        // Send string data
        auto result = client_->send_packet("Hello, QUIC Server!");
        if (result.is_ok())
        {
            std::cout << "Sent string message on default stream" << std::endl;
        }
        else
        {
            std::cerr << "Failed to send: " << result.error().message << std::endl;
        }
 
        // Send binary data
        std::vector<uint8_t> binary_data = {0x01, 0x02, 0x03, 0x04, 0x05};
        result = client_->send_packet(std::move(binary_data));
        if (result.is_ok())
        {
            std::cout << "Sent binary data on default stream" << std::endl;
        }
        else
        {
            std::cerr << "Failed to send: " << result.error().message << std::endl;
        }
    }

References client_, and kcenon::network::core::messaging_quic_client::send_packet().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

bool QuicClientDemo::run ( )

inline

Definition at line 52 of file quic_client_example.cpp.

    {
        std::cout << "=== QUIC Client Example ===" << std::endl;
        std::cout << "Connecting to " << server_host_ << ":" << server_port_ << std::endl;
 
        // Create QUIC client directly for QUIC-specific features
        client_ = std::make_shared<core::messaging_quic_client>("quic_demo_client");
 
        // Set up callbacks
        setup_callbacks();
 
        // Start the client
        auto result = client_->start_client(server_host_, server_port_);
        if (result.is_err())
        {
            std::cerr << "Failed to start client: " << result.error().message << std::endl;
            return false;
        }
 
        std::cout << "Client started, waiting for connection..." << std::endl;
 
        // Wait for connection (with timeout)
        {
            std::unique_lock<std::mutex> lock(mutex_);
            bool connected = cv_.wait_for(lock, std::chrono::seconds(10), [this]() {
                return connected_.load();
            });
 
            if (!connected)
            {
                std::cerr << "Connection timeout" << std::endl;
                (void)client_->stop_client();
                return false;
            }
        }
 
        std::cout << "Connected to server!" << std::endl;
 
        // Demo: Send data on default stream
        demo_send_default_stream();
 
        // Demo: Create and use multiple streams
        demo_multi_stream();
 
        // Wait a bit for responses
        std::this_thread::sleep_for(std::chrono::seconds(2));
 
        // Get statistics
        auto stats = client_->stats();
        std::cout << "\n=== Connection Statistics ===" << std::endl;
        std::cout << "Bytes sent: " << stats.bytes_sent << std::endl;
        std::cout << "Bytes received: " << stats.bytes_received << std::endl;
        std::cout << "Packets sent: " << stats.packets_sent << std::endl;
        std::cout << "Packets received: " << stats.packets_received << std::endl;
        std::cout << "Packets lost: " << stats.packets_lost << std::endl;
 
        // Stop the client
        std::cout << "\nStopping client..." << std::endl;
        (void)client_->stop_client();
        client_->wait_for_stop();
 
        std::cout << "Client stopped." << std::endl;
        return true;
    }

References client_, kcenon::network::connected, connected_, cv_, demo_multi_stream(), demo_send_default_stream(), mutex_, server_host_, server_port_, setup_callbacks(), kcenon::network::core::messaging_quic_client::start_client(), kcenon::network::core::messaging_quic_client::stats(), kcenon::network::core::messaging_quic_client::stop_client(), and kcenon::network::core::messaging_quic_client::wait_for_stop().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_callbacks()

void QuicClientDemo::setup_callbacks ( )

inlineprivate

Definition at line 118 of file quic_client_example.cpp.

    {
        // Connected callback
        client_->set_connected_callback([this]() {
            std::cout << "[Callback] Connected to server" << std::endl;
            connected_.store(true);
            cv_.notify_all();
        });
 
        // Disconnected callback
        client_->set_disconnected_callback([this]() {
            std::cout << "[Callback] Disconnected from server" << std::endl;
            connected_.store(false);
        });
 
        // Error callback
        client_->set_error_callback([](std::error_code ec) {
            std::cerr << "[Callback] Error: " << ec.message() << std::endl;
        });
 
        // Receive callback for default stream
        client_->set_receive_callback([this](const std::vector<uint8_t>& data) {
            std::string msg(data.begin(), data.end());
            std::cout << "[Callback] Received on default stream: " << msg << std::endl;
            message_received_.store(true);
        });
 
        // Stream receive callback for all streams
        client_->set_stream_receive_callback(
            [](uint64_t stream_id, const std::vector<uint8_t>& data, bool fin) {
                std::string msg(data.begin(), data.end());
                std::cout << "[Callback] Stream " << stream_id << ": "
                          << data.size() << " bytes"
                          << (fin ? " (FIN)" : "") << std::endl;
                std::cout << "  Data: " << msg << std::endl;
            });
    }

References client_, connected_, cv_, message_received_, kcenon::network::core::messaging_quic_client::set_connected_callback(), kcenon::network::core::messaging_quic_client::set_disconnected_callback(), kcenon::network::core::messaging_quic_client::set_error_callback(), kcenon::network::core::messaging_quic_client::set_receive_callback(), and kcenon::network::core::messaging_quic_client::set_stream_receive_callback().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

client_

std::shared_ptr<core::messaging_quic_client> QuicClientDemo::client_

private

Definition at line 243 of file quic_client_example.cpp.

Referenced by demo_multi_stream(), demo_send_default_stream(), run(), and setup_callbacks().

connected_

std::atomic<bool> QuicClientDemo::connected_

private

Definition at line 244 of file quic_client_example.cpp.

Referenced by run(), and setup_callbacks().

cv_

std::condition_variable QuicClientDemo::cv_

private

Definition at line 247 of file quic_client_example.cpp.

Referenced by run(), and setup_callbacks().

message_received_

std::atomic<bool> QuicClientDemo::message_received_

private

Definition at line 245 of file quic_client_example.cpp.

Referenced by setup_callbacks().

mutex_

std::mutex QuicClientDemo::mutex_

private

Definition at line 246 of file quic_client_example.cpp.

Referenced by run().

server_host_

std::string QuicClientDemo::server_host_

private

Definition at line 241 of file quic_client_example.cpp.

Referenced by run().

server_port_

unsigned short QuicClientDemo::server_port_

private

Definition at line 242 of file quic_client_example.cpp.

Referenced by run().

---

The documentation for this class was generated from the following file:

• examples/quic_client_example.cpp