[#BloombergLP-bslx-TestInStream]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslx.adoc[bslx]::TestInStream
:relfileprefix: ../../
:mrdocs:

This class provides input methods to unexternalize values, and C&hyphen;style arrays of values, of fundamental types from their byte representations&period; Each input method also verifies the input value type&period; By default, if invalid data is detected, error messages are displayed on `stdout`&semi; this error reporting may be disabled via the `setQuiet` method&period; Note that attempting to read beyond the end of a stream will automatically invalidate the stream&period; See the `bslx` package&hyphen;level documentation for the definition of the BDEX `InStream` protocol&period;

== Synopsis

Declared in `&lt;bslx&lowbar;testinstream&period;h&gt;`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class TestInStream;
----

== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslx/TestInStream/2constructor-073.adoc[`TestInStream`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bslx/TestInStream/2destructor.adoc[`&#126;TestInStream`] [.small]#[destructor]#
| Destroy this test input stream&period;
| xref:BloombergLP/bslx/TestInStream/cursor.adoc[`cursor`] 
| Return the index of the next byte to be extracted from this stream&period;
| xref:BloombergLP/bslx/TestInStream/data.adoc[`data`] 
| Return the address of the contiguous, non&hyphen;modifiable external memory buffer of this stream&period; The behavior of accessing elements outside the range `&lsqb; data() &period;&period; data() &plus; (length() &hyphen; 1) &rsqb;` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getArrayFloat32.adoc[`getArrayFloat32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE single&hyphen;precision (4&hyphen;byte) floating&hyphen;point array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period; Note that for non&hyphen;conforming platforms, this operation may be lossy&period;
| xref:BloombergLP/bslx/TestInStream/getArrayFloat64.adoc[`getArrayFloat64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE double&hyphen;precision (8&hyphen;byte) floating&hyphen;point array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period; Note that for non&hyphen;conforming platforms, this operation may be lossy&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt16.adoc[`getArrayInt16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 16&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt24.adoc[`getArrayInt24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 24&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt32.adoc[`getArrayInt32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 32&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt40.adoc[`getArrayInt40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 40&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt48.adoc[`getArrayInt48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 48&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt56.adoc[`getArrayInt56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 56&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt64.adoc[`getArrayInt64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 64&hyphen;bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayInt8-07.adoc[`getArrayInt8`] 
| `getArrayInt8` overloads
| xref:BloombergLP/bslx/TestInStream/getArrayUint16.adoc[`getArrayUint16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 16&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint24.adoc[`getArrayUint24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 24&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint32.adoc[`getArrayUint32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 32&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint40.adoc[`getArrayUint40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 40&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint48.adoc[`getArrayUint48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 48&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint56.adoc[`getArrayUint56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 56&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint64.adoc[`getArrayUint64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 64&hyphen;bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined&period; The behavior is undefined unless `0 &lt;&equals; numVariables` and `variables` has sufficient capacity&period;
| xref:BloombergLP/bslx/TestInStream/getArrayUint8-0d.adoc[`getArrayUint8`] 
| `getArrayUint8` overloads
| xref:BloombergLP/bslx/TestInStream/getFloat32.adoc[`getFloat32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE single&hyphen;precision (4&hyphen;byte) floating&hyphen;point value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period; Note that for non&hyphen;conforming platforms, this operation may be lossy&period;
| xref:BloombergLP/bslx/TestInStream/getFloat64.adoc[`getFloat64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE double&hyphen;precision (8&hyphen;byte) floating&hyphen;point value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period; Note that for non&hyphen;conforming platforms, this operation may be lossy&period;
| xref:BloombergLP/bslx/TestInStream/getInt16.adoc[`getInt16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 16&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt24.adoc[`getInt24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 24&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt32.adoc[`getInt32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 32&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt40.adoc[`getInt40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 40&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt48.adoc[`getInt48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 48&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt56.adoc[`getInt56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 56&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt64.adoc[`getInt64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 64&hyphen;bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getInt8-07.adoc[`getInt8`] 
| `getInt8` overloads
| xref:BloombergLP/bslx/TestInStream/getLength.adoc[`getLength`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 8&hyphen;bit unsigned integer or 32&hyphen;bit signed integer value representing a length (see the `bslx` package&hyphen;level documentation) into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; Consume an 8&hyphen;bit unsigned integer if the most significant bit of this byte is 0, otherwise consume a 32&hyphen;bit signed integer and set the most significant bit to zero in the resultant `variable`&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getString.adoc[`getString`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume a string from this input stream, assign that value to the specified `variable`, update the cursor location, and return a reference to this stream&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period; The string must be prefaced by a non&hyphen;negative integer indicating the number of characters composing the string&period; The behavior is undefined unless the length indicator is non&hyphen;negative&period;
| xref:BloombergLP/bslx/TestInStream/getUint16.adoc[`getUint16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 16&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint24.adoc[`getUint24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 24&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint32.adoc[`getUint32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 32&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint40.adoc[`getUint40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 40&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint48.adoc[`getUint48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 48&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint56.adoc[`getUint56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 56&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint64.adoc[`getUint64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 64&hyphen;bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/getUint8-0d.adoc[`getUint8`] 
| `getUint8` overloads
| xref:BloombergLP/bslx/TestInStream/getVersion.adoc[`getVersion`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`)&semi; otherwise, consume the 8&hyphen;bit unsigned integer type code, verify the type of the next value in this stream, consume that 8&hyphen;bit unsigned integer value representing a version (see the `bslx` package&hyphen;level documentation) into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream&period; If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged&period; If this stream is initially invalid, this operation has no effect&period; If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined&period;
| xref:BloombergLP/bslx/TestInStream/inputLimit.adoc[`inputLimit`] 
| Return the current number of input requests left before an exception is thrown&period; A negative value indicates that no exception is scheduled&period;
| xref:BloombergLP/bslx/TestInStream/invalidate.adoc[`invalidate`] 
| Put this input stream in an invalid state&period; This function has no effect if this stream is already invalid&period; Note that this function should be called whenever a value extracted from this stream is determined to be invalid, inconsistent, or otherwise incorrect&period;
| xref:BloombergLP/bslx/TestInStream/isEmpty.adoc[`isEmpty`] 
| Return `true` if this stream is empty, and `false` otherwise&period; Note that this function enables higher&hyphen;level types to verify that, after successfully reading all expected data, no data remains&period;
| xref:BloombergLP/bslx/TestInStream/isQuiet.adoc[`isQuiet`] 
| Return `true` if this stream&apos;s quiet mode is ON, and `false` otherwise&period;
| xref:BloombergLP/bslx/TestInStream/isValid.adoc[`isValid`] 
| Return `true` if this stream is valid, and `false` otherwise&period; An invalid stream is a stream in which insufficient or invalid data was detected during an extraction operation&period; Note that an empty stream will be valid unless an extraction attempt or explicit invalidation causes it to be otherwise&period;
| xref:BloombergLP/bslx/TestInStream/length.adoc[`length`] 
| Return the total number of bytes stored in the external memory buffer&period;
| xref:BloombergLP/bslx/TestInStream/reset-0a.adoc[`reset`] 
| `reset` overloads
| xref:BloombergLP/bslx/TestInStream/seek.adoc[`seek`] 
| Set the index of the next byte to be extracted from this stream to the specified `offset` from the beginning of the stream, and validate this stream if it is currently invalid&period; The behavior is undefined unless `offset &lt;&equals; length()`&period;
| xref:BloombergLP/bslx/TestInStream/setInputLimit.adoc[`setInputLimit`] 
| Set the number of input operations allowed on this stream to the specified `limit` before an exception is thrown&period; If `limit` is less than 0, no exception is to be thrown&period; By default, no exception is scheduled&period;
| xref:BloombergLP/bslx/TestInStream/setQuiet.adoc[`setQuiet`] 
| Set the quiet mode for this test stream to the specified (boolean) `flagValue`&period; If `flagValue` is `true`, then quiet mode is turned ON and no error messages will be written to standard output&period; If `flagValue` is `false`, then quiet mode is turned OFF&period; Note that quiet mode is turned OFF by default&period;
| xref:BloombergLP/bslx/TestInStream/2conversion.adoc[`operator void const*`] 
| Return a non&hyphen;zero value if this stream is valid, and 0 otherwise&period; An invalid stream is a stream for which an input operation was detected to have failed&period;
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:BloombergLP/bslx/operator_lshift-0a1.adoc[BloombergLP::bslx::operator&lt;&lt;]`
| Write the specified `object` to the specified output `stream` in some reasonable (multi&hyphen;line) format, and return a reference to `stream`&period;
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslx/operator_rshift-0c.adoc[`operator&gt;&gt;`]
| Read the specified `value` from the specified input `stream` following the requirements of the BDEX protocol (see the `bslx` package&hyphen;level documentation), and return a reference to `stream`&period; The behavior is undefined unless `TYPE` is BDEX&hyphen;compliant&period;
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#
