A client class demonstrating concept-constrained callbacks. More...

Collaboration diagram for ConceptClient:

Public Member Functions
template<DataReceiveHandler Handler>
void	on_data (Handler &&handler)
	Set data receive handler.

template<ErrorHandler Handler>
void	on_error (Handler &&handler)
	Set error handler.

template<ConnectionHandler Handler>
void	on_connect (Handler &&handler)
	Set connection handler.

template<RetryCallback Handler>
void	on_retry (Handler &&handler)
	Set retry callback.

void	simulate_events ()

Private Attributes
std::function< void(const std::vector< uint8_t > &)>	data_handler_

std::function< void(std::error_code)>	error_handler_

std::function< void()>	connect_handler_

std::function< void(std::size_t)>	retry_handler_

Detailed Description

A client class demonstrating concept-constrained callbacks.

Definition at line 105 of file concepts_example.cpp.

Member Function Documentation

◆ on_connect()

template<ConnectionHandler Handler>

void ConceptClient::on_connect ( Handler && handler )

inline

Set connection handler.

Template Parameters

Handler Must be callable with no arguments

Definition at line 132 of file concepts_example.cpp.

                                       {
        connect_handler_ = std::forward<Handler>(handler);
        std::cout << "Connect handler registered\n";
    }

References connect_handler_.

◆ on_data()

template<DataReceiveHandler Handler>

void ConceptClient::on_data ( Handler && handler )

inline

Set data receive handler.

Template Parameters

Handler Must be callable with const std::vector<uint8_t>&

Definition at line 112 of file concepts_example.cpp.

                                    {
        data_handler_ = std::forward<Handler>(handler);
        std::cout << "Data handler registered\n";
    }

References data_handler_.

◆ on_error()

template<ErrorHandler Handler>

void ConceptClient::on_error ( Handler && handler )

inline

Set error handler.

Template Parameters

Handler Must be callable with std::error_code

Definition at line 122 of file concepts_example.cpp.

                                     {
        error_handler_ = std::forward<Handler>(handler);
        std::cout << "Error handler registered\n";
    }

References error_handler_.

◆ on_retry()

template<RetryCallback Handler>

void ConceptClient::on_retry ( Handler && handler )

inline

Set retry callback.

Template Parameters

Handler Must be callable with std::size_t (attempt number)

Definition at line 142 of file concepts_example.cpp.

                                     {
        retry_handler_ = std::forward<Handler>(handler);
        std::cout << "Retry handler registered\n";
    }

References retry_handler_.

◆ simulate_events()

void ConceptClient::simulate_events ( )

inline

Definition at line 148 of file concepts_example.cpp.

                           {
        std::cout << "\nSimulating events:\n";
 
        if (connect_handler_) {
            std::cout << "  -> Connection event: ";
            connect_handler_();
        }
 
        if (data_handler_) {
            std::vector<uint8_t> data = {72, 101, 108, 108, 111};  // "Hello"
            std::cout << "  -> Data event: ";
            data_handler_(data);
        }
 
        if (retry_handler_) {
            std::cout << "  -> Retry event: ";
            retry_handler_(3);
        }
 
        if (error_handler_) {
            std::cout << "  -> Error event: ";
            error_handler_(std::make_error_code(std::errc::connection_refused));
        }
    }