Write up to 64 bits, advancing pos. If autoexpand is enabled, will advance end as well and/or realloc if buffer full If disables, panics if exceeds en

Similar to read_bits, but returns a ParseError::BufferEnded with the given error_string if not enough bits are available.

Parse type3 field into a placeholder struct, pending implementation. Checks whether a given type3 field identifier is present. If not, returns None wi

Write an optional Type-3 element using a `to_bitbuf` function.

Write one Type-2 element. If `value` is `Some(v)`, writes P-bit=1 then `len` bits of `v`. If `None`, writes P-bit=0.

Seek to a specific position in the file

Read the o-bit between type1 and type2/type3 elements

Number of bits left in the window (bits), from pos to end.

Sets up logging with maximum verbosity (trace level) Mainly for unit tests

Write the m-bit before a type3 or type4 element, and trailing the message

Write the o-bit between type1 and type2/type3 elements

Active window length (bits), from start to end

Convert this enum back into the raw integer value

Add a number of timeslots to a TdmaTime

Access immutable config.

Checks if the given address falls within any of the ranges. Note that range.end is inclusive, so if an address is exactly equal to range.end, it is co

Get absolute value of window start

Peek `num_bits` at the current pos, without advancing. Returns None on overflow or if `num_bits>64`.

Get absolute current position, disregarding start and end of window

Move window end. Ensure new_end >= max(pos, start) and new_end <= capacity

Write a little-endian u32 to a byte vec

Automatically add a set of components and sinks to the stack. Depending on the stack mode, the components will be created with the appropriate BS or M

Read `num_bits` at the current pos, advancing on success.

Move window start. Ensure new_start <= min(end, pos)

Read `num_bits` from a source bitbuffer, starting at `pos`. Write this data into the current bitbuffer at the current `pos`.

Takes slice as parameter for output. Reads slice.len() bits from bitbuf[pos], and writes to output slice. 1 bit per byte.

Seek `pos` to `offset` (relative to window start).

Convert this enum back into the raw integer value

Move pos to absolute location, irrespective of window. Ensure start <= pos <= end

Write guard for mutable state.

Non-blocking: receive a pending command, if any.

Writes the next chunk to the bitbuffer, if there is space. First chunk is the provided resource, possibly changed to indicate fragmentation. Subsequen

Convert this enum back into the raw integer value

Create a bidirectional (dispatcher, endpoint) pair. - The **dispatcher** (worker side) sends [`ControlCommand`]s and receives [`ControlResponse`]s. -

Write a single bit to pos

Tolerant registration; if ISSI already registered, we overwrite it with a fresh Subscriber struct

Get the current position, relative to window

Convert this enum back into the raw integer value

Peek `num_bits` with offset from window start, without advancing. Returns None on overflow or if `num_bits>64`.

Move the current bit‐pointer by `offset` bits (can be negative). Panics if the resulting position would lie outside the window `[start..=end]`.

Convert the entire window (start to end) into a String of '0'/'1' characters.

Returns the number of fill bits at the end of the PDU in bitbuf, given the total pdu_len_bits.

Convert entire window (start to end) into an array with 0 or 1 value per byte

Determine if a given GSSI should be routed over Brew, or is restricted to local handling

Pending → Transmitted: MAC layer has sent the PDU over the air.

Parse a raw binary Brew message into a typed BrewMessage

Parse a Type-2 element into a struct that implements `from_bitbuf`.

Tries to find a way to satisfy a granting request, and reserves the slots in the schedule. If successful, returns a BasicSlotgrant with the granting d

Write a Type-2 element from a struct that implements `to_bitbuf`.

Add GSSI to subscriber's attached groups and global set

Count D-SDS-DATA messages (LcmcMleUnitdataReq to Mle) in sink output

Get absolute value of window end, disregarding start of window

Read a little-endian u32 from a byte slice

Helper: register a subscriber ISSI in the StackState subscriber registry

Read guard for mutable state.

Remove GSSI from subscriber's attached groups. Update global set if no more subscribers are affiliated with this GSSI.

Get a sample with a given delay

Parse a Type-4 element into a Vec of structs that implement `from_bitbuf`.

Get the current file position

Return true if processing should be continued, false if a new demodulated slot is available.

Scramble or unscramble the given BitBuffer. Generate lfsr sequence for given lfsr initialization value and XOR it with the given buffer, for all bits

Compute the initial LFSR state from (mcc, mnc, colour).

Internal send implementation - does the actual I/O

Write a Type-4 element from a Vec of structs using a `to_bitbuf` function.

Write a little-endian u16 to a byte vec

Decode bitcode bytes into a [`TelemetryEvent`].

Decodes control plane message from type5 to type1 bits Returns (buf, bool) tuple buf is BitBuffer with type1 bits if decoding successful bool is true

Deregister an ISSI, removing it from the registry and cleaning up any group affiliations

Registers that we should transmit a MAC-RESOURCE or similar with a grant, somewhere this tick

Encode a [`Command`] to bitcode bytes.

Encodes control plane message from type1 to type5 bits Handles CP channels except AACH