Compared to `Deref`, this propagates the lifetime of the reference

Try to get the node at the given [`SchemaKey`] (or return `None` if the key is invalid) If you want to panic on invalid keys, use `schema[key]` inst

Deserialize from an avro "datum" (raw data, no headers...) slice This is zero-alloc. Your structure may contain `&'a str`s that will end up pointing

Iterator over the deserialized values

The fully qualified name e.g. in `a.b.c` it's `a.b.c`

Flush the final block (if a block was started) then return the underlying writer.

Check that last block is complete and advertise end (zero-sized block)

Get writer by reference This may be useful to observe the state of the inner buffer, notably when re-using a `SerializerState` to write multiple obje

Flush the current block (if a block was started) After this function is called, if it returned no error, it is guaranteed that the full block is writ

Gives the name of the logical type, as it appears in the schema JSON

Obtain the actual [`serde::Deserializer`] for this `DeserializerState`

Turn the `DeserializerState` into the reader it was built from, also extracting the original configuration (in case that needs to be re-used)

Get writer back

The namespace component of the fully qualified name e.g. in `a.b.c` it's `a.b`

Obtain the actual [`serde::Serializer`] for this `SerializerState`

Serialize an avro "datum" (raw data, no headers...) to the provided writer [`SerializerConfig`](ser::SerializerConfig) can be built from a schema: `

may be unused depending on which compression codecs features are enabled

Obtain the index in the [`nodes`](SchemaMut::nodes) `Vec` of a [`SchemaMut`] that this [`SchemaKey`] points to.

Reserve a slot in the `nodes` array After building the `SchemaNode`, it should be put at the corresponding position in `nodes`.

Obtain the root of the Schema It is the first node of the `nodes` `Vec`. # Panics If the `nodes` `Vec` is empty. This can only happen if you have up

Get writer by mutable reference This may be useful to clear the inner buffer, when re-using a `SerializerState`.

Build the [`Writer`] After this method is called, it is guaranteed that the full object container file encoding header is already written to the `wri

Returned boolean is `has_non_lifetime_generics`

Attempt to deserialize the next value via the advanced [`DeserializeSeed`] serde API A typical user should not need this. This may be useful for tra

Deserialize from an avro "datum" (raw data, no headers...) `impl BufRead` If you only have an `impl Read`, wrap it in a [`BufReader`](std::io::BufRea

If the type is a named type, returns the name of the type.

Make sure we aren't cycling

Serialize one value as an object in the object container file

If this node was already written, return true (don't write it again). Otherwise, return false, assume we'll write it entirely and increment the counte

For when you can't use `serde_bytes` and really need to serialize a sequence as bytes. If you need to serialize a `Vec<u8>` or `&[u8]` as `Bytes`/`Fi

Obtain the Rabin fingerprint of the schema This is what is used for avro [single object encoding](https://avro.apache.org/docs/current/specification/

Check that the schema does not contain zero-sized unconditional cycles. This is called by the parsing functions already, so this may only be useful i

Specify the compression codec that each block will be compressed with

Iterator over the deserialized values This can only be used if reading directly from a slice (Reader built via [`Reader::from_slice`], `R = `[`SliceR

may be unused depending on which compression codecs features are enabled

may be unused depending on which compression codecs features are enabled

Obtain the underlying graph storage The first node (index `0`) is the root of the schema. [`SchemaKey`]s can be converted to indexes of this `Vec`.

Obtain the Rabin fingerprint of the schema

Get the schema that was used when creating this `SerializerConfig`. That is the one that will be used when building a serializer from this `Serialize