Enum Record 

#[non_exhaustive]
pub enum Record {
    #[non_exhaustive]
    Raw {
        bytes: Bytes,
        format: Format,
    },
    Parsed(Value),
}

A record that can be forwarded without parsing or parsed for inspection.

This is the core abstraction for zero-copy forwarding. A Record is either:

• Raw: Unparsed bytes with a format hint. Can be forwarded without parsing.
• Parsed: A parsed Value tree. Efficient for inspection and modification.

Zero-Copy Forwarding

use structfs_core_store::{Record, Format};
use bytes::Bytes;

// Data comes in as raw bytes
let record = Record::raw(Bytes::from_static(b"{\"name\":\"Alice\"}"), Format::JSON);

// Forward without parsing - just pass the Record through
// No JSON parsing happens!

Lazy Parsing

use structfs_core_store::{Record, Format, Value};
use bytes::Bytes;

let record = Record::raw(Bytes::from_static(b"..."), Format::JSON);

// Only parse when you need to inspect
// let value = record.into_value(&codec)?;

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

#[non_exhaustive]

Raw

Unparsed bytes with format hint.

The bytes can be forwarded without parsing. Use into_value() to parse when you need to inspect or modify the data.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

bytes: Bytes

The raw bytes.

format: Format

Hint about the format (JSON, protobuf, etc.)

Parsed(Value)

Parsed tree structure.

Efficient for inspection and modification. Use into_bytes() to serialize when you need to send over the wire.

Implementations

impl Record

pub fn raw(bytes: impl Into<Bytes>, format: Format) -> Record

Create a record from raw bytes.

pub fn parsed(value: Value) -> Record

Create a record from a parsed value.

pub fn is_raw(&self) -> bool

Check if this record is in raw (unparsed) form.

pub fn is_parsed(&self) -> bool

Check if this record is parsed.

pub fn format(&self) -> Format

Get the format hint.

For Parsed records, returns Format::VALUE.

pub fn as_bytes(&self) -> Option<&Bytes>

Get raw bytes if available without serialization.

Returns None for Parsed records (would require serialization).

pub fn as_value(&self) -> Option<&Value>

Get parsed value if available without parsing.

Returns None for Raw records (would require parsing).

pub fn into_value(self, codec: &dyn Codec) -> Result<Value, Error>

Parse into a Value.

• For Parsed records: returns the value (no cost).
• For Raw records: parses the bytes using the codec.

This is where you pay the parsing cost.

pub fn into_bytes( self, codec: &dyn Codec, target_format: &Format, ) -> Result<Bytes, Error>

Serialize into bytes.

• For Raw records with matching format: returns the bytes (no cost).
• For Raw records with different format: transcodes via Value.
• For Parsed records: serializes using the codec.

This is where you pay the serialization cost.

pub fn try_into_bytes(self, target_format: &Format) -> Result<Bytes, Record>

Try to get bytes without serialization, returning the record if not possible.

Useful when you want bytes if available, but don’t want to pay serialization cost.

Trait Implementations

impl Clone for Record

fn clone(&self) -> Record

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Record

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Record

fn deserialize<D>( deserializer: D, ) -> Result<Record, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Bytes> for Record

fn from(bytes: Bytes) -> Record

Converts to this type from the input type.

impl From<Value> for Record

fn from(v: Value) -> Record

Converts to this type from the input type.

impl Serialize for Record

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.