Struct ValueCodecRegistry

Source

pub struct ValueCodecRegistry<D: 'static> { /* private fields */ }

Expand description

An immutable value-codec registry sorted by stable ID.

§Type Parameters

D: Static descriptor type identifying one wire representation. The registry API is implemented for descriptors that also satisfy Copy.

§Examples

use qubit_codec::ValueCodecRegistry;
use qubit_codec::ValueStringCodecDescriptor;
use qubit_codec::ValueStringCodecRegistry;

let registry: ValueCodecRegistry<ValueStringCodecDescriptor> =
    ValueStringCodecRegistry::empty();
assert!(registry.get("missing.example").is_none());

Implementations§

Source §

impl ValueCodecRegistry<ValueBytesCodecDescriptor>

Source

pub fn try_global() -> Result<&'static Self, ValueCodecRegistryError>

Initializes and returns the process-wide linked bytes registry.

Initialization is synchronized and cached, including construction failures.

§Returns

A shared static registry containing all linked bytes registrations.

§Errors

Returns the cached construction error when linked registrations conflict. The error identifies the lexically first duplicate ID and all declarations for that ID in source-field order.

Source

pub fn global() -> &'static Self

Returns the process-wide bytes registry or panics with a stable diagnostic.

§Returns

A shared static registry, initialized at most once by try_global.

§Panics

Panics when linked registrations conflict.

Source §

impl ValueCodecRegistry<ValueStringCodecDescriptor>

Source

pub fn try_global() -> Result<&'static Self, ValueCodecRegistryError>

Initializes and returns the process-wide linked string registry.

Initialization is synchronized and cached, including construction failures.

§Returns

A shared static registry containing all linked string registrations.

§Errors

Returns the cached construction error when linked registrations conflict. The error identifies the lexically first duplicate ID and all declarations for that ID in source-field order.

Source

pub fn global() -> &'static Self

Returns the process-wide string registry or panics with a stable diagnostic.

§Returns

A shared static registry, initialized at most once by try_global.

§Panics

Panics when linked registrations conflict.

Source §

impl<D: Copy + 'static> ValueCodecRegistry<D>

Source

pub fn from_registrations( registrations: impl IntoIterator<Item = &'static ValueCodecRegistration<D>>, ) -> Result<Self, ValueCodecRegistryError>

Builds a local registry from static registrations without consulting or modifying the process-wide registry.

§Parameters

registrations: Static entries copied into this registry; input order is ignored.

§Returns

An owned, immutable registry sorted by ID, independent of the iterator.

§Errors

Returns a duplicate-ID error when multiple entries claim one ID.

§Examples

This example uses a local static registration; it does not submit an entry to the process-wide inventory.

use std::convert::Infallible;
use qubit_codec::ValueCodecId;
use qubit_codec::ValueCodecRegistration;
use qubit_codec::ValueCodecRegistrationSource;
use qubit_codec::ValueDecoder;
use qubit_codec::ValueEncoder;
use qubit_codec::ValueStringCodecDescriptor;
use qubit_codec::ValueStringCodecRegistration;
use qubit_codec::ValueStringCodecRegistry;

#[derive(Default)]
struct LocalText;

impl ValueEncoder<String> for LocalText {
    type Output = String;
    type Error = Infallible;

    fn encode(&mut self, input: &String) -> Result<String, Infallible> {
        Ok(input.clone())
    }
}

impl ValueDecoder<str> for LocalText {
    type Output = String;
    type Error = Infallible;

    fn decode(&mut self, input: &str) -> Result<String, Infallible> {
        Ok(input.to_owned())
    }
}

static DESCRIPTOR: ValueStringCodecDescriptor =
    ValueStringCodecDescriptor::of::<LocalText, String>();
static REGISTRATION: ValueStringCodecRegistration = ValueCodecRegistration::new(
    ValueCodecId::new("example.local.text"),
    &DESCRIPTOR,
    ValueCodecRegistrationSource::new("local-example", "example", file!(), line!()),
);

let registry = ValueStringCodecRegistry::from_registrations([&REGISTRATION])
    .expect("unique local registration");
let descriptor = registry.get("example.local.text")
    .expect("registered locally").descriptor();
let encoded = descriptor.encode(&String::from("hello")).expect("encode");
assert_eq!("hello", encoded);
let decoded = descriptor.decode(&encoded).expect("decode");
assert_eq!("hello", *decoded.downcast::<String>().expect("String output"));
assert!(registry.get("example.missing").is_none());