kcenon::network::protocols::quic::stream_manager Class Reference

Manages QUIC streams within a connection. More...

#include <stream_manager.h>

Collaboration diagram for kcenon::network::protocols::quic::stream_manager:

Public Member Functions
	stream_manager (bool is_server, uint64_t initial_max_stream_data=65536)
	Construct a stream manager.
	~stream_manager ()=default
	stream_manager (const stream_manager &)=delete
auto	operator= (const stream_manager &) -> stream_manager &=delete
	stream_manager (stream_manager &&)=delete
auto	operator= (stream_manager &&) -> stream_manager &=delete
auto	create_bidirectional_stream () -> Result< uint64_t >
	Create a new locally-initiated bidirectional stream.
auto	create_unidirectional_stream () -> Result< uint64_t >
	Create a new locally-initiated unidirectional stream.
auto	get_stream (uint64_t stream_id) -> stream *
	Get a stream by ID.
auto	get_stream (uint64_t stream_id) const -> const stream *
	Get a stream by ID (const version)
auto	get_or_create_stream (uint64_t stream_id) -> Result< stream * >
	Get or create a stream for a peer-initiated stream ID.
auto	has_stream (uint64_t stream_id) const -> bool
	Check if a stream exists.
auto	stream_ids () const -> std::vector< uint64_t >
	Get all active stream IDs.
auto	stream_count () const -> size_t
	Get number of active streams.
void	set_peer_max_streams_bidi (uint64_t max)
	Set maximum bidirectional streams peer can initiate.
void	set_peer_max_streams_uni (uint64_t max)
	Set maximum unidirectional streams peer can initiate.
auto	local_max_streams_bidi () const noexcept -> uint64_t
	Get our maximum bidirectional streams (advertised to peer)
auto	local_max_streams_uni () const noexcept -> uint64_t
	Get our maximum unidirectional streams (advertised to peer)
void	set_local_max_streams_bidi (uint64_t max)
	Set our maximum bidirectional streams (advertised to peer)
void	set_local_max_streams_uni (uint64_t max)
	Set our maximum unidirectional streams (advertised to peer)
auto	peer_max_streams_bidi () const noexcept -> uint64_t
	Get peer's maximum bidirectional streams (limits our creation)
auto	peer_max_streams_uni () const noexcept -> uint64_t
	Get peer's maximum unidirectional streams (limits our creation)
auto	streams_with_pending_data () -> std::vector< stream * >
	Get streams with pending data to send.
auto	streams_needing_flow_control_update () -> std::vector< stream * >
	Get streams that need MAX_STREAM_DATA updates.
void	for_each_stream (const std::function< void(stream &)> &callback)
	Iterate over all streams.
void	for_each_stream (const std::function< void(const stream &)> &callback) const
	Iterate over all streams (const version)
auto	remove_closed_streams () -> size_t
	Remove closed/terminal streams.
void	close_all_streams (uint64_t error_code)
	Close all streams with an error code.
void	reset ()
	Reset manager state (for connection close)
auto	local_bidi_streams_count () const noexcept -> uint64_t
	Get count of locally-initiated bidirectional streams.
auto	local_uni_streams_count () const noexcept -> uint64_t
	Get count of locally-initiated unidirectional streams.
auto	peer_bidi_streams_count () const noexcept -> uint64_t
	Get count of peer-initiated bidirectional streams.
auto	peer_uni_streams_count () const noexcept -> uint64_t
	Get count of peer-initiated unidirectional streams.

Private Member Functions
auto	validate_stream_id (uint64_t stream_id) const -> VoidResult
auto	is_local_stream (uint64_t stream_id) const noexcept -> bool
auto	can_create_local_stream (bool bidirectional) const -> bool
auto	can_accept_peer_stream (uint64_t stream_id) const -> bool

Private Attributes
bool	is_server_
uint64_t	initial_max_stream_data_
uint64_t	next_local_bidi_id_
uint64_t	next_local_uni_id_
uint64_t	highest_peer_bidi_id_ {0}
uint64_t	highest_peer_uni_id_ {0}
uint64_t	peer_bidi_type_
uint64_t	peer_uni_type_
uint64_t	local_max_streams_bidi_ {100}
uint64_t	local_max_streams_uni_ {100}
uint64_t	peer_max_streams_bidi_ {0}
uint64_t	peer_max_streams_uni_ {0}
std::shared_mutex	streams_mutex_
std::map< uint64_t, std::unique_ptr< stream > >	streams_

Detailed Description

Manages QUIC streams within a connection.

Handles stream creation, lookup, and lifecycle management according to RFC 9000 Sections 2-4. Supports both client and server roles with proper stream ID assignment.

Definition at line 29 of file stream_manager.h.

Constructor & Destructor Documentation

stream_manager() [1/3]

kcenon::network::protocols::quic::stream_manager::stream_manager ( bool is_server, uint64_t initial_max_stream_data = 65536 )

explicit

Construct a stream manager.

Parameters

is_server	True if this is a server-side manager
initial_max_stream_data	Initial flow control limit per stream

Definition at line 10 of file stream_manager.cpp.

    : is_server_{is_server}
    , initial_max_stream_data_{initial_max_stream_data}
    , next_local_bidi_id_{is_server ? stream_id_type::server_bidi : stream_id_type::client_bidi}
    , next_local_uni_id_{is_server ? stream_id_type::server_uni : stream_id_type::client_uni}
    , peer_bidi_type_{is_server ? stream_id_type::client_bidi : stream_id_type::server_bidi}
    , peer_uni_type_{is_server ? stream_id_type::client_uni : stream_id_type::server_uni}
{
}

~stream_manager()

kcenon::network::protocols::quic::stream_manager::~stream_manager ( )

default

stream_manager() [2/3]

kcenon::network::protocols::quic::stream_manager::stream_manager ( const stream_manager & )

delete

stream_manager() [3/3]

kcenon::network::protocols::quic::stream_manager::stream_manager ( stream_manager && )

delete

Member Function Documentation

can_accept_peer_stream()

auto kcenon::network::protocols::quic::stream_manager::can_accept_peer_stream ( uint64_t stream_id ) const -> bool

nodiscardprivate

Definition at line 367 of file stream_manager.cpp.

{
    const bool is_bidi = stream_id_type::is_bidirectional(stream_id);
    const uint64_t stream_seq = stream_id_type::get_sequence(stream_id);
 
    if (is_bidi) {
        // Check against our MAX_STREAMS_BIDI
        return stream_seq < local_max_streams_bidi_;
    } else {
        // Check against our MAX_STREAMS_UNI
        return stream_seq < local_max_streams_uni_;
    }
}

References kcenon::network::protocols::quic::stream_id_type::get_sequence(), and kcenon::network::protocols::quic::stream_id_type::is_bidirectional().

Here is the call graph for this function:

can_create_local_stream()

auto kcenon::network::protocols::quic::stream_manager::can_create_local_stream ( bool bidirectional ) const -> bool

nodiscardprivate

Definition at line 354 of file stream_manager.cpp.

{
    if (bidirectional) {
        // Check against peer's MAX_STREAMS_BIDI
        const uint64_t current_count = next_local_bidi_id_ / 4;
        return current_count < peer_max_streams_bidi_;
    } else {
        // Check against peer's MAX_STREAMS_UNI
        const uint64_t current_count = (next_local_uni_id_ - 2) / 4;
        return current_count < peer_max_streams_uni_;
    }
}

close_all_streams()

void kcenon::network::protocols::quic::stream_manager::close_all_streams

(

uint64_t

error_code

)

Close all streams with an error code.

Parameters

error_code

Error code to use for reset

Definition at line 296 of file stream_manager.cpp.

{
    std::unique_lock lock(streams_mutex_);
    for (auto& [_, s] : streams_) {
        if (s->can_send()) {
            (void)s->reset(error_code);
        }
    }
}

References streams_, and streams_mutex_.

create_bidirectional_stream()

auto kcenon::network::protocols::quic::stream_manager::create_bidirectional_stream ( ) -> Result<uint64_t>

nodiscard

Create a new locally-initiated bidirectional stream.

Returns

Stream ID or error

Definition at line 24 of file stream_manager.cpp.

{
    if (!can_create_local_stream(true)) {
        return error<uint64_t>(stream_error::stream_limit_exceeded,
                              "Bidirectional stream limit reached",
                              "quic::stream_manager");
    }
 
    std::unique_lock lock(streams_mutex_);
 
    uint64_t stream_id = next_local_bidi_id_;
    next_local_bidi_id_ += 4;
 
    auto new_stream = std::make_unique<stream>(stream_id, true, initial_max_stream_data_);
    streams_[stream_id] = std::move(new_stream);
 
    return ok(std::move(stream_id));
}

References kcenon::network::protocols::quic::error, kcenon::network::ok(), and kcenon::network::protocols::quic::stream_error::stream_limit_exceeded.

Here is the call graph for this function:

create_unidirectional_stream()

auto kcenon::network::protocols::quic::stream_manager::create_unidirectional_stream ( ) -> Result<uint64_t>

nodiscard

Create a new locally-initiated unidirectional stream.

Returns

Stream ID or error

Definition at line 43 of file stream_manager.cpp.

{
    if (!can_create_local_stream(false)) {
        return error<uint64_t>(stream_error::stream_limit_exceeded,
                              "Unidirectional stream limit reached",
                              "quic::stream_manager");
    }
 
    std::unique_lock lock(streams_mutex_);
 
    uint64_t stream_id = next_local_uni_id_;
    next_local_uni_id_ += 4;
 
    auto new_stream = std::make_unique<stream>(stream_id, true, initial_max_stream_data_);
    streams_[stream_id] = std::move(new_stream);
 
    return ok(std::move(stream_id));
}

References kcenon::network::protocols::quic::error, kcenon::network::ok(), and kcenon::network::protocols::quic::stream_error::stream_limit_exceeded.

Here is the call graph for this function:

for_each_stream() [1/2]

void kcenon::network::protocols::quic::stream_manager::for_each_stream

(

const std::function< void(const stream &)> &

callback

)

const

Iterate over all streams (const version)

Parameters

callback

Function to call for each stream

Definition at line 238 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    for (const auto& [_, s] : streams_) {
        callback(*s);
    }
}

References streams_, and streams_mutex_.

for_each_stream() [2/2]

void kcenon::network::protocols::quic::stream_manager::for_each_stream

(

const std::function< void(stream &)> &

callback

)

Iterate over all streams.

Parameters

callback

Function to call for each stream

Definition at line 230 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    for (auto& [_, s] : streams_) {
        callback(*s);
    }
}

References streams_, and streams_mutex_.

get_or_create_stream()

auto kcenon::network::protocols::quic::stream_manager::get_or_create_stream ( uint64_t stream_id ) -> Result<stream*>

nodiscard

Get or create a stream for a peer-initiated stream ID.

Parameters

stream_id

Stream identifier

Returns

Pointer to stream or error

This is used when receiving data for a stream that may not exist yet. Peer-initiated streams are implicitly created when first referenced.

Definition at line 80 of file stream_manager.cpp.

{
    // First, try to get existing stream
    {
        std::shared_lock lock(streams_mutex_);
        auto it = streams_.find(stream_id);
        if (it != streams_.end()) {
            return ok(it->second.get());
        }
    }
 
    // Validate stream ID
    auto validation = validate_stream_id(stream_id);
    if (validation.is_err()) {
        return error<stream*>(validation.error().code,
                             validation.error().message,
                             "quic::stream_manager");
    }
 
    // Check if this is a peer-initiated stream
    if (is_local_stream(stream_id)) {
        return error<stream*>(stream_error::stream_not_found,
                             "Local stream must be explicitly created",
                             "quic::stream_manager");
    }
 
    // Check stream limits for peer-initiated stream
    if (!can_accept_peer_stream(stream_id)) {
        return error<stream*>(stream_error::stream_limit_exceeded,
                             "Peer stream limit exceeded",
                             "quic::stream_manager");
    }
 
    // Create implicit streams as needed (RFC 9000 Section 2.1)
    // When a stream is created, all lower-numbered streams of the same type
    // must also be created
    std::unique_lock lock(streams_mutex_);
 
    const auto type = stream_id_type::get_type(stream_id);
    const bool is_bidi = stream_id_type::is_bidirectional(stream_id);
 
    // Determine the first stream ID of this type we need to create
    uint64_t first_id = type;
    if (is_bidi) {
        if (highest_peer_bidi_id_ > 0 || streams_.count(peer_bidi_type_) > 0) {
            first_id = highest_peer_bidi_id_ + 4;
        }
    } else {
        if (highest_peer_uni_id_ > 0 || streams_.count(peer_uni_type_) > 0) {
            first_id = highest_peer_uni_id_ + 4;
        }
    }
 
    // Create all streams up to and including the requested one
    for (uint64_t id = first_id; id <= stream_id; id += 4) {
        if (streams_.count(id) == 0) {
            auto new_stream = std::make_unique<stream>(id, false, initial_max_stream_data_);
            streams_[id] = std::move(new_stream);
        }
    }
 
    // Update highest peer stream ID
    if (is_bidi) {
        if (stream_id > highest_peer_bidi_id_ || highest_peer_bidi_id_ == 0) {
            highest_peer_bidi_id_ = stream_id;
        }
    } else {
        if (stream_id > highest_peer_uni_id_ || highest_peer_uni_id_ == 0) {
            highest_peer_uni_id_ = stream_id;
        }
    }
 
    return ok(streams_[stream_id].get());
}

References kcenon::network::protocols::quic::error, kcenon::network::protocols::quic::stream_id_type::get_type(), kcenon::network::protocols::quic::stream_id_type::is_bidirectional(), kcenon::network::ok(), kcenon::network::protocols::quic::stream_error::stream_limit_exceeded, and kcenon::network::protocols::quic::stream_error::stream_not_found.

Here is the call graph for this function:

get_stream() [1/2]

auto kcenon::network::protocols::quic::stream_manager::get_stream ( uint64_t stream_id ) -> stream*

nodiscard

Get a stream by ID.

Parameters

stream_id

Stream identifier

Returns

Pointer to stream or nullptr if not found

Definition at line 66 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    auto it = streams_.find(stream_id);
    return (it != streams_.end()) ? it->second.get() : nullptr;
}

get_stream() [2/2]

auto kcenon::network::protocols::quic::stream_manager::get_stream ( uint64_t stream_id ) const -> const stream*

nodiscard

Get a stream by ID (const version)

Parameters

stream_id

Stream identifier

Returns

Pointer to stream or nullptr if not found

Definition at line 73 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    auto it = streams_.find(stream_id);
    return (it != streams_.end()) ? it->second.get() : nullptr;
}

has_stream()

auto kcenon::network::protocols::quic::stream_manager::has_stream ( uint64_t stream_id ) const -> bool

nodiscard

Check if a stream exists.

Parameters

stream_id

Stream identifier

Definition at line 155 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    return streams_.count(stream_id) > 0;
}

is_local_stream()

auto kcenon::network::protocols::quic::stream_manager::is_local_stream ( uint64_t stream_id ) const -> bool

nodiscardprivatenoexcept

Definition at line 348 of file stream_manager.cpp.

{
    const bool is_server_initiated = stream_id_type::is_server_initiated(stream_id);
    return is_server_initiated == is_server_;
}

References kcenon::network::protocols::quic::stream_id_type::is_server_initiated().

Here is the call graph for this function:

local_bidi_streams_count()

auto kcenon::network::protocols::quic::stream_manager::local_bidi_streams_count ( ) const -> uint64_t

inlinenodiscardnoexcept

Get count of locally-initiated bidirectional streams.

Definition at line 225 of file stream_manager.h.

    {
        return next_local_bidi_id_ / 4;
    }

References next_local_bidi_id_.

local_max_streams_bidi()

auto kcenon::network::protocols::quic::stream_manager::local_max_streams_bidi ( ) const -> uint64_t

inlinenodiscardnoexcept

Get our maximum bidirectional streams (advertised to peer)

Definition at line 128 of file stream_manager.h.

    {
        return local_max_streams_bidi_;
    }

References local_max_streams_bidi_.

local_max_streams_uni()

auto kcenon::network::protocols::quic::stream_manager::local_max_streams_uni ( ) const -> uint64_t

inlinenodiscardnoexcept

Get our maximum unidirectional streams (advertised to peer)

Definition at line 136 of file stream_manager.h.

    {
        return local_max_streams_uni_;
    }

References local_max_streams_uni_.

local_uni_streams_count()

auto kcenon::network::protocols::quic::stream_manager::local_uni_streams_count ( ) const -> uint64_t

inlinenodiscardnoexcept

Get count of locally-initiated unidirectional streams.

Definition at line 233 of file stream_manager.h.

    {
        return (next_local_uni_id_ - 2) / 4;
    }

References next_local_uni_id_.

operator=() [1/2]

auto kcenon::network::protocols::quic::stream_manager::operator= ( const stream_manager & ) -> stream_manager &=delete

delete

operator=() [2/2]

auto kcenon::network::protocols::quic::stream_manager::operator= ( stream_manager && ) -> stream_manager &=delete

delete

peer_bidi_streams_count()

auto kcenon::network::protocols::quic::stream_manager::peer_bidi_streams_count ( ) const -> uint64_t

inlinenodiscardnoexcept

Get count of peer-initiated bidirectional streams.

Definition at line 241 of file stream_manager.h.

    {
        return (highest_peer_bidi_id_ + 4 - peer_bidi_type_) / 4;
    }

References highest_peer_bidi_id_, and peer_bidi_type_.

peer_max_streams_bidi()

auto kcenon::network::protocols::quic::stream_manager::peer_max_streams_bidi ( ) const -> uint64_t

inlinenodiscardnoexcept

Get peer's maximum bidirectional streams (limits our creation)

Definition at line 156 of file stream_manager.h.

    {
        return peer_max_streams_bidi_;
    }

References peer_max_streams_bidi_.

peer_max_streams_uni()

auto kcenon::network::protocols::quic::stream_manager::peer_max_streams_uni ( ) const -> uint64_t

inlinenodiscardnoexcept

Get peer's maximum unidirectional streams (limits our creation)

Definition at line 164 of file stream_manager.h.

    {
        return peer_max_streams_uni_;
    }

References peer_max_streams_uni_.

peer_uni_streams_count()

auto kcenon::network::protocols::quic::stream_manager::peer_uni_streams_count ( ) const -> uint64_t

inlinenodiscardnoexcept

Get count of peer-initiated unidirectional streams.

Definition at line 249 of file stream_manager.h.

    {
        return (highest_peer_uni_id_ + 4 - peer_uni_type_) / 4;
    }

References highest_peer_uni_id_, and peer_uni_type_.

remove_closed_streams()

auto kcenon::network::protocols::quic::stream_manager::remove_closed_streams

(

)

-> size_t

Remove closed/terminal streams.

Returns

Number of streams removed

Definition at line 250 of file stream_manager.cpp.

{
    std::unique_lock lock(streams_mutex_);
    size_t removed = 0;
 
    for (auto it = streams_.begin(); it != streams_.end();) {
        const auto& s = it->second;
 
        // Check if stream is in terminal state on both sides
        bool send_terminal = (s->send_state() == send_stream_state::data_recvd ||
                             s->send_state() == send_stream_state::reset_recvd);
        bool recv_terminal = (s->recv_state() == recv_stream_state::data_read ||
                             s->recv_state() == recv_stream_state::reset_read);
 
        // For unidirectional streams, only check the relevant side
        if (s->is_unidirectional()) {
            if (s->is_local()) {
                // Local unidirectional: only check send side
                if (send_terminal) {
                    it = streams_.erase(it);
                    ++removed;
                    continue;
                }
            } else {
                // Peer unidirectional: only check receive side
                if (recv_terminal) {
                    it = streams_.erase(it);
                    ++removed;
                    continue;
                }
            }
        } else {
            // Bidirectional: check both sides
            if (send_terminal && recv_terminal) {
                it = streams_.erase(it);
                ++removed;
                continue;
            }
        }
 
        ++it;
    }
 
    return removed;
}

References kcenon::network::protocols::quic::data_read, kcenon::network::protocols::quic::data_recvd, kcenon::network::protocols::quic::reset_read, and kcenon::network::protocols::quic::reset_recvd.

reset()

void kcenon::network::protocols::quic::stream_manager::reset

(

)

Reset manager state (for connection close)

Definition at line 306 of file stream_manager.cpp.

{
    std::unique_lock lock(streams_mutex_);
    streams_.clear();
 
    // Reset stream ID counters
    next_local_bidi_id_ = is_server_ ? stream_id_type::server_bidi : stream_id_type::client_bidi;
    next_local_uni_id_ = is_server_ ? stream_id_type::server_uni : stream_id_type::client_uni;
    highest_peer_bidi_id_ = 0;
    highest_peer_uni_id_ = 0;
}

References kcenon::network::protocols::quic::stream_id_type::client_bidi, kcenon::network::protocols::quic::stream_id_type::client_uni, highest_peer_bidi_id_, highest_peer_uni_id_, is_server_, next_local_bidi_id_, next_local_uni_id_, kcenon::network::protocols::quic::stream_id_type::server_bidi, kcenon::network::protocols::quic::stream_id_type::server_uni, streams_, and streams_mutex_.

set_local_max_streams_bidi()

void kcenon::network::protocols::quic::stream_manager::set_local_max_streams_bidi

(

uint64_t

max

)

Set our maximum bidirectional streams (advertised to peer)

Parameters

max	Maximum stream count

Definition at line 192 of file stream_manager.cpp.

{
    local_max_streams_bidi_ = max;
}

References local_max_streams_bidi_.

Referenced by kcenon::network::protocols::quic::connection::set_local_params().

Here is the caller graph for this function:

set_local_max_streams_uni()

void kcenon::network::protocols::quic::stream_manager::set_local_max_streams_uni

(

uint64_t

max

)

Set our maximum unidirectional streams (advertised to peer)

Parameters

max	Maximum stream count

Definition at line 197 of file stream_manager.cpp.

{
    local_max_streams_uni_ = max;
}

References local_max_streams_uni_.

Referenced by kcenon::network::protocols::quic::connection::set_local_params().

Here is the caller graph for this function:

set_peer_max_streams_bidi()

void kcenon::network::protocols::quic::stream_manager::set_peer_max_streams_bidi

(

uint64_t

max

)

Set maximum bidirectional streams peer can initiate.

Parameters

max	Maximum stream count

Definition at line 182 of file stream_manager.cpp.

{
    peer_max_streams_bidi_ = max;
}

References peer_max_streams_bidi_.

Referenced by kcenon::network::protocols::quic::connection::apply_remote_params().

Here is the caller graph for this function:

set_peer_max_streams_uni()

void kcenon::network::protocols::quic::stream_manager::set_peer_max_streams_uni

(

uint64_t

max

)

Set maximum unidirectional streams peer can initiate.

Parameters

max	Maximum stream count

Definition at line 187 of file stream_manager.cpp.

{
    peer_max_streams_uni_ = max;
}

References peer_max_streams_uni_.

Referenced by kcenon::network::protocols::quic::connection::apply_remote_params().

Here is the caller graph for this function:

stream_count()

auto kcenon::network::protocols::quic::stream_manager::stream_count ( ) const -> size_t

nodiscard

Get number of active streams.

Definition at line 172 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    return streams_.size();
}

References streams_, and streams_mutex_.

stream_ids()

auto kcenon::network::protocols::quic::stream_manager::stream_ids ( ) const -> std::vector<uint64_t>

nodiscard

Get all active stream IDs.

Definition at line 161 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    std::vector<uint64_t> ids;
    ids.reserve(streams_.size());
    for (const auto& [id, _] : streams_) {
        ids.push_back(id);
    }
    return ids;
}

References streams_, and streams_mutex_.

streams_needing_flow_control_update()

auto kcenon::network::protocols::quic::stream_manager::streams_needing_flow_control_update ( ) -> std::vector<stream*>

nodiscard

Get streams that need MAX_STREAM_DATA updates.

Returns

Vector of stream pointers

Definition at line 218 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    std::vector<stream*> result;
    for (auto& [_, s] : streams_) {
        if (s->should_send_max_stream_data()) {
            result.push_back(s.get());
        }
    }
    return result;
}

streams_with_pending_data()

auto kcenon::network::protocols::quic::stream_manager::streams_with_pending_data ( ) -> std::vector<stream*>

nodiscard

Get streams with pending data to send.

Returns

Vector of stream pointers

Definition at line 206 of file stream_manager.cpp.

{
    std::shared_lock lock(streams_mutex_);
    std::vector<stream*> result;
    for (auto& [_, s] : streams_) {
        if (s->pending_bytes() > 0 || (s->fin_sent() && !s->is_fin_received())) {
            result.push_back(s.get());
        }
    }
    return result;
}

Referenced by kcenon::network::protocols::quic::connection::has_pending_data().

Here is the caller graph for this function:

validate_stream_id()

auto kcenon::network::protocols::quic::stream_manager::validate_stream_id ( uint64_t stream_id ) const -> VoidResult

nodiscardprivate

Definition at line 322 of file stream_manager.cpp.

{
    const auto type = stream_id_type::get_type(stream_id);
 
    // Check if stream type is valid for the role
    if (is_local_stream(stream_id)) {
        // Local stream: check against our limits
        const bool is_bidi = stream_id_type::is_bidirectional(stream_id);
        if (is_bidi) {
            if (stream_id >= next_local_bidi_id_) {
                return error_void(stream_error::invalid_stream_id,
                                 "Local bidi stream ID too high",
                                 "quic::stream_manager");
            }
        } else {
            if (stream_id >= next_local_uni_id_) {
                return error_void(stream_error::invalid_stream_id,
                                 "Local uni stream ID too high",
                                 "quic::stream_manager");
            }
        }
    }
 
    return ok();
}

References kcenon::network::error_void(), kcenon::network::protocols::quic::stream_id_type::get_type(), kcenon::network::protocols::quic::stream_error::invalid_stream_id, kcenon::network::protocols::quic::stream_id_type::is_bidirectional(), and kcenon::network::ok().

Here is the call graph for this function:

Member Data Documentation

highest_peer_bidi_id_

uint64_t kcenon::network::protocols::quic::stream_manager::highest_peer_bidi_id_ {0}

private

Definition at line 265 of file stream_manager.h.

{0};

Referenced by peer_bidi_streams_count(), and reset().

highest_peer_uni_id_

uint64_t kcenon::network::protocols::quic::stream_manager::highest_peer_uni_id_ {0}

private

Definition at line 266 of file stream_manager.h.

{0};

Referenced by peer_uni_streams_count(), and reset().

initial_max_stream_data_

uint64_t kcenon::network::protocols::quic::stream_manager::initial_max_stream_data_

private

Definition at line 256 of file stream_manager.h.

is_server_

bool kcenon::network::protocols::quic::stream_manager::is_server_

private

Definition at line 255 of file stream_manager.h.

Referenced by reset().

local_max_streams_bidi_

uint64_t kcenon::network::protocols::quic::stream_manager::local_max_streams_bidi_ {100}

private

Definition at line 271 of file stream_manager.h.

{100};

Referenced by local_max_streams_bidi(), and set_local_max_streams_bidi().

local_max_streams_uni_

uint64_t kcenon::network::protocols::quic::stream_manager::local_max_streams_uni_ {100}

private

Definition at line 272 of file stream_manager.h.

{100};

Referenced by local_max_streams_uni(), and set_local_max_streams_uni().

next_local_bidi_id_

uint64_t kcenon::network::protocols::quic::stream_manager::next_local_bidi_id_

private

Definition at line 261 of file stream_manager.h.

Referenced by local_bidi_streams_count(), and reset().

next_local_uni_id_

uint64_t kcenon::network::protocols::quic::stream_manager::next_local_uni_id_

private

Definition at line 262 of file stream_manager.h.

Referenced by local_uni_streams_count(), and reset().

peer_bidi_type_

uint64_t kcenon::network::protocols::quic::stream_manager::peer_bidi_type_

private

Definition at line 267 of file stream_manager.h.

Referenced by peer_bidi_streams_count().

peer_max_streams_bidi_

uint64_t kcenon::network::protocols::quic::stream_manager::peer_max_streams_bidi_ {0}

private

Definition at line 273 of file stream_manager.h.

{0};

Referenced by peer_max_streams_bidi(), and set_peer_max_streams_bidi().

peer_max_streams_uni_

uint64_t kcenon::network::protocols::quic::stream_manager::peer_max_streams_uni_ {0}

private

Definition at line 274 of file stream_manager.h.

{0};

Referenced by peer_max_streams_uni(), and set_peer_max_streams_uni().

peer_uni_type_

uint64_t kcenon::network::protocols::quic::stream_manager::peer_uni_type_

private

Definition at line 268 of file stream_manager.h.

Referenced by peer_uni_streams_count().

streams_

std::map<uint64_t, std::unique_ptr<stream> > kcenon::network::protocols::quic::stream_manager::streams_

private

Definition at line 278 of file stream_manager.h.

Referenced by close_all_streams(), for_each_stream(), for_each_stream(), reset(), stream_count(), and stream_ids().

streams_mutex_

std::shared_mutex kcenon::network::protocols::quic::stream_manager::streams_mutex_

mutableprivate

Definition at line 277 of file stream_manager.h.

Referenced by close_all_streams(), for_each_stream(), for_each_stream(), reset(), stream_count(), and stream_ids().

---

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

• src/internal/protocols/quic/stream_manager.h
• src/protocols/quic/stream_manager.cpp