🥮 mooncakes.io

    starAndHonor/fst/codec does not have a README file

    CodecError

    source
    pub suberror CodecError {
      InvalidFormat(String)
    } derive(
    Debug    )

    Malformed, unsupported, or internally inconsistent serialized data.

    CodecError::to_repr

    source

    pub(all) struct Header {
      version : UInt64
      fst_type : UInt64
      len : UInt64
      root : Int
    } derive(Eq, 
    Debug    )

    Header and footer metadata. len counts accepted keys, not stored nodes.

    Header::equal

    source
    fn Header::equal(Header, Header) -> Bool

    Header::not_equal

    source
    fn Header::not_equal(x : Header, y : Header) -> Bool

    Header::to_repr

    source

    Node

    source
    pub(all) struct Node {
      address : Int
      is_final : Bool
      final_output : UInt64
      transitions : Array[Transition]
    } derive(Eq, 
    Debug    )

    An owned, bounds-checked view of one decoded node.

    Node::equal

    source
    fn Node::equal(Node, Node) -> Bool

    Node::not_equal

    source
    fn Node::not_equal(x : Node, y : Node) -> Bool

    Node::to_repr

    source

    Transition

    source
    pub(all) struct Transition {
      input : Byte
      output : UInt64
      addr : Int
    } derive(Eq, 
    Debug    )

    A transition in ascending input-byte order. Address zero is the implicit final state; all other addresses point to the last byte of a stored node.

    Transition::equal

    source
    fn Transition::equal(Transition, Transition) -> Bool

    Transition::not_equal

    source
    fn Transition::not_equal(x : Transition, y : Transition) -> Bool

    Transition::to_repr

    source

    begin

    source
    fn begin(fst_type : UInt64) -> Array[Byte]

    Starts a version 3 FST. The type tag is opaque to the raw format.

    crc32c

    source
    fn crc32c(data : Bytes) -> UInt

    Standard CRC32C, initialized and finalized with all bits inverted.

    finish

    source
    fn finish(buffer : Array[Byte], root~ : Int, len~ : UInt64) -> Bytes

    Appends key count, root address, and masked CRC32C, returning owned bytes.

    masked_crc32c

    source
    fn masked_crc32c(data : Bytes) -> UInt

    Snappy's masked CRC32C, as stored in the version 3 fst footer.

    read_header

    source
    fn read_header(data : Bytes) -> Header raise CodecError

    Reads metadata for Rust fst versions 1, 2, and 3. This validates offsets; call verify as well to validate the graph, path outputs, and checksum.

    read_node

    source
    fn read_node(data : Bytes, header : Header, address : Int) -> Node raise CodecError

    Safely decodes one node, including transition ordering and indexed input consistency. verify additionally checks referenced nodes and whole paths.

    verify

    source
    fn verify(data : Bytes) -> Unit raise CodecError

    Validates every reachable node without recursive calls or key expansion. Backward-only edges rule out cycles. Dynamic programming on addresses checks the accepted-key count and every possible accumulated output for overflow.

    write_node

    source
    fn write_node(buffer : Array[Byte], is_final : Bool, final_output : UInt64, transitions : Array[Transition]) -> Int

    Appends one node, selecting implicit-final, one-transition-next, one-transition, or general encoding. Inputs must be sorted and unique; targets must already have been written, or be the implicit address zero.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io