CounterBasedGenerator32<TEngine> Structure

public struct CounterBasedGenerator32<TEngine> : IBlockRandomGenerator, 
	IRandomGenerator, IStateful, ICounterBased<uint>, IAdvanceable
where TEngine : struct, new(), ICounterBased<uint>, IBlockEngine<uint>, IStateful

Public Structure CounterBasedGenerator32(Of TEngine As {Structure, New, ICounterBased(Of UInteger), IBlockEngine(Of UInteger), IStateful})
	Implements IBlockRandomGenerator, IRandomGenerator, IStateful, ICounterBased(Of UInteger), 
	IAdvanceable

generic<typename TEngine>
where TEngine : value class, gcnew(), ICounterBased<unsigned int>, IBlockEngine<unsigned int>, IStateful
public value class CounterBasedGenerator32 : IBlockRandomGenerator, 
	IRandomGenerator, IStateful, ICounterBased<unsigned int>, 
	IAdvanceable

[<SealedAttribute>]
type CounterBasedGenerator32<'TEngine when 'TEngine : struct, new() and ICounterBased<uint32> and IBlockEngine<uint32> and IStateful> = 
    struct
        inherit ValueType
        interface IBlockRandomGenerator
        interface IRandomGenerator
        interface IStateful
        interface ICounterBased<uint32>
        interface IAdvanceable
    end

Inheritance

Object  →  ValueType  →  CounterBasedGenerator32<TEngine>

Implements

ICounterBased<UInt32>, IAdvanceable, IBlockRandomGenerator, IRandomGenerator, IStateful

Type Parameters

TEngine

The engine type, which must be a struct implementing ICounterBased<T> and IBlockEngine<T> for UInt32, and IStateful.

CounterBasedGenerator32<TEngine> wraps a counter-based engine (e.g., Philox-4x32) and provides:

• NextUInt32(): Returns the next word from the current block via engine.Output(index).
• NextUInt64(): Composes two 32-bit words in little-endian order.
• NextBytes(Span<Byte>): Writes bytes via NextUInt32() in 4-byte chunks (little-endian), with tail handling.

Refill Policy (Advance-on-Empty, Consistent-by-Contract):

When the block is exhausted (_index == BlockLength), the generator calls AdvanceBlock() which advances the counter by one block and establishes a consistent state for the new block coordinates. The generator then resets _index = 0. This ensures the engine is always in a consistent state when Output(Int32) is called.

Consistency Guarantee:

All generator methods guarantee that whenever they produce output from the engine, the engine is in a consistent state. AdvanceBlock(UInt64) is guaranteed by Layer 1 to leave the engine consistent, so Layer 2 does not need to call GenerateBlock() in the normal refill path.

State Persistence:

Layer 2 state includes engine state (including any engine-owned cached block material) plus the cursor index (4 bytes LE).

Reference