Cardano.Ledger.Binary.Plain

Decode a bool.

Attempt to decode a Break token, and if that was successful, return True. If the token was of any other type, return False.

Decode a string of bytes as a ByteArray.

Also note that this will eagerly copy the content out of the input to ensure that the input does not leak in the event that the ByteArray is live but not forced.

Decode canonical representation of a string of bytes as a ByteArray.

Also note that this will eagerly copy the content out of the input to ensure that the input does not leak in the event that the ByteArray is live but not forced.

Decode a string of bytes as a ByteString.

Decode canonical representation of a string of bytes as a ByteString.

Decode a token marking the beginning of an indefinite length set of bytes.

Decode a Double.

Decode canonical representation of a Double.

Decode a Float.

Decode canonical representation of a half-precision Float.

Decode canonical representation of a Float.

Decode an Int.

Decode an Int16.

Decode canonical representation of an Int16.

Decode an Int32.

Decode canonical representation of an Int32.

Decode an Int64.

Decode canonical representation of an Int64.

Decode an Int8.

Decode canonical representation of an Int8.

Decode canonical representation of an Int.

Decode an Integer.

Decode canonical representation of an Integer.

Decode the length of a list.

Decode canonical representation of the length of a list.

Attempt to decode canonical representation of a list length using decodeListLenCanonical, and ensure it is exactly the specified length, or fail.

Decode a token marking the beginning of a list of indefinite length.

Attempt to decode a list length using decodeListLen, and ensure it is exactly the specified length, or fail.

Attempt to decode a token for the length of a finite, known list, or an indefinite list. If Nothing is returned, then an indefinite length list occurs afterwords. If Just x is returned, then a list of length x is encoded.

Decode the length of a map.

Decode canonical representation of the length of a map.

Decode a token marking the beginning of a map of indefinite length.

Attempt to decode a token for the length of a finite, known map, or an indefinite map. If Nothing is returned, then an indefinite length map occurs afterwords. If Just x is returned, then a map of length x is encoded.

Decode a negative Word.

Decode a negative Word64.

Decode canonical representation of a negative Word64.

Decode canonical representation of a negative Word.

Decode a nullary value, and return a unit value.

Decode an indefinite sequence length.

Decode a sequence length.

Decode a simple CBOR value and give back a Word8. You probably don't ever need to use this.

Decode canonical representation of a simple CBOR value and give back a Word8. You probably don't ever need to use this.

Decode a textual string as a piece of Text.

Decode canonical representation of a textual string as a piece of Text.

Decode a token marking the beginning of an indefinite length string.

Decode an arbitrary tag and return it as a Word.

Decode an arbitrary 64-bit tag and return it as a Word64.

Decode canonical representation of an arbitrary 64-bit tag and return it as a Word64.

Decode canonical representation of an arbitrary tag and return it as a Word.

Decode a textual string as UTF-8 encoded ByteArray. Note that the result is not validated to be well-formed UTF-8.

Also note that this will eagerly copy the content out of the input to ensure that the input does not leak in the event that the ByteArray is live but not forced.

Decode canonical representation of a textual string as UTF-8 encoded ByteArray. Note that the result is not validated to be well-formed UTF-8.

Also note that this will eagerly copy the content out of the input to ensure that the input does not leak in the event that the ByteArray is live but not forced.

This captures the pattern of getting the byte offsets before and after decoding a subterm.

!before <- peekByteOffset
x <- decode
!after  <- peekByteOffset

Decode a Word.

Decode a Word16.

Decode canonical representation of a Word16.

Decode a Word32.

Decode canonical representation of a Word32.

Decode a Word64.

Decode canonical representation of a Word64.

Decode a Word8.

Decode canonical representation of a Word8.

Decode canonical representation of a Word.

Attempt to decode canonical representation of a word with decodeWordCanonical, and ensure the word is exactly as expected, or fail.

Attempt to decode a word with decodeWord, and ensure the word is exactly as expected, or fail.

Given a Decoder, give us the DecodeAction

Lift an ST action into a Decoder. Useful for, e.g., leveraging in-place mutation to efficiently build a deserialised value.

Peek and return the length of the current buffer that we're running our decoder on.

Get the current ByteOffset in the input byte sequence of the Decoder.

The Decoder does not provide any facility to get at the input data directly (since that is tricky with an incremental decoder). The next best is this primitive which can be used to keep track of the offset within the input bytes that makes up the encoded form of a term.

By keeping track of the byte offsets before and after decoding a subterm (a pattern captured by decodeWithByteSpan) and if the overall input data is retained then this is enables later retrieving the span of bytes for the subterm.

Peek at the current token we're about to decode, and return a TokenType specifying what it is.

Encode a Bool.

Encode a 'break', used to specify the end of indefinite length objects like maps or lists.

Encode a bytestring in a flattened format.

Encode an arbitrary strict ByteString in a flattened format.

Encode a token specifying the beginning of a string of bytes of indefinite length. In reality, this specifies a stream of many occurrences of encodeBytes, each specifying a single chunk of the overall string. After all the bytes desired have been encoded, you should follow it with a break token (see encodeBreak).

Encode a Double in a flattened format.

Encode a full precision Float in a flattened format.

Encode a small 16-bit Float in a flattened format.

Encode an Int in a flattened format.

Encode an Int16 in a flattened format.

Encode an Int32 in a flattened format.

Encode an @Int64 in a flattened format.

Encode an Int8 in a flattened format.

Encode an arbitrarily large @Integer in a flattened format.

Encode the length of a list, used to indicate that the following tokens represent the list values.

Encode a token specifying that this is the beginning of an indefinite list of unknown size. Tokens representing the list are expected afterwords, followed by a break token (see encodeBreak) when the list has ended.

Encode the length of a Map, used to indicate that the following tokens represent the map values.

Encode a token specifying that this is the beginning of an indefinite map of unknown size. Tokens representing the map are expected afterwords, followed by a break token (see encodeBreak) when the map has ended.

Encode a Null value.

Include pre-encoded valid CBOR data into the Encoding.

The data is included into the output as-is without any additional wrapper.

This should be used with care. The data must be a valid CBOR encoding, but this is not checked.

This is useful when you have CBOR data that you know is already valid, e.g. previously validated and stored on disk, and you wish to include it without having to decode and re-encode it.

Encode a 'simple' CBOR token that can be represented with an 8-bit word. You probably don't ever need this.

Encode a Text in a flattened format.

Encode the beginning of an indefinite string.

Encode an arbitrary Word tag.

Encode an arbitrary 64-bit Word64 tag.

Encode an Undef value.

Encode a UTF-8 string in a flattened format. Note that the contents is not validated to be well-formed UTF-8.

Encode a Word in a flattened format.

Encode a Word16 in a flattened format.

Encode a Word32 in a flattened format.

Encode a Word64 in a flattened format.

Encode a Word8 in a flattened format.

Decode some arbitrary CBOR value into a Term.

Encode an arbitrary Term into an Encoding for later serialization.

Turn an Encoding into a strict ByteString in CBOR binary format.

A 0-based offset within the overall byte sequence that makes up the input to the Decoder.

This is an Int64 since Decoder is incremental and can decode more data than fits in memory at once. This is also compatible with the result type of length.

An action, representing a step for a decoder to taken and a continuation to invoke with the expected value.

A continuation-based decoder, used for decoding values that were previously encoded using the Codec.CBOR.Encoding module. As Decoder has a Monad instance, you can easily write Decoders monadically for building your deserialisation logic.

The type of a token, which a decoder can ask for at an arbitrary time.

An intermediate form used during serialisation, specified as a Monoid. It supports efficient concatenation, and is equivalent to a specialised Endo Tokens type.

It is used for the stage in serialisation where we flatten out the Haskell data structure but it is independent of any specific external binary or text format.

Traditionally, to build any arbitrary Encoding value, you specify larger structures from smaller ones and append the small ones together using mconcat.

A flattened representation of a term, which is independent of any underlying binary representation, but which we later serialise into CBOR format.

A general CBOR term, which can be used to serialise or deserialise arbitrary CBOR terms for interoperability or debugging. This type is essentially a direct reflection of the CBOR abstract syntax tree as a Haskell data type.

The Term type also comes with a Serialise instance, so you can easily use decode :: Decoder Term to directly decode any arbitrary CBOR value into Haskell with ease, and likewise with encode.