Struct Classification

Generated from cargo doc --no-deps -p nemo-relay -p nemo-relay-adaptive -p nemo-relay-pii-redaction -p nemo-relay-ffi -p nemo-relay-types -p nemo-relay-plugin -p nemo-relay-worker-proto -p nemo-relay-worker.

pub struct Classification { /* private fields */ }

Shared classification payload for producers, projections, and decoded evidence.

Typed constructors validate built-in code/cause pairs and borrow their stable names. Decoded future names remain opaque. Core validates recording input and resolves admitted identifiers before changing counters or retaining evidence. Transport adapters must bound received names before materializing owned data. Private fields prevent mutation after construction. Explicit opaque-name construction and deserialization preserve evidence without asserting validity.

use nemo_relay_types::diagnostics::{Classification, SuccessCode};
let mut value = Classification::success(SuccessCode::SinkInitialized);
value.canonical_code = "different.name".into();

Implementations

`impl Classification`

impl Classification

`from_opaque_names`

pub fn from_opaque_names(
    canonical_code: Cow<'static, str>,
    failure_class: Option<Cow<'static, str>>,
) -> Classification

Preserve names from a wire payload or an admitted extension descriptor. This does not validate catalogue membership or authorize recording. Core revalidates every recording input, including values decoded with Serde.

`into_names`

pub fn into_names(self) -> (Cow<'static, str>, Option<Cow<'static, str>>)

Consume the payload without cloning borrowed names or owned buffers.

`new`

pub fn new(
    code: BuiltinDiagnosticCode,
    failure_class: Option<FailureClass>,
) -> Result<Classification, ClassificationError>

Validate the required cause and the catalogue entry’s permitted classes.

`failure`

pub fn failure(
    code: FailureCode,
    failure_class: FailureClass,
) -> Result<Classification, ClassificationError>

Classify a failure using an explicitly supported cause.

`success`

pub const fn success(code: SuccessCode) -> Classification

Classify an observed success, without clearing previous failures.

`notice`

pub const fn notice(code: NoticeCode) -> Classification

Classify an observed notice, without inventing a failure cause.

`code`

pub fn code(&self) -> &str

Borrow the canonical name, including an opaque future name.

`failure_class`

pub fn failure_class(&self) -> Option<&str>

Borrow the observed cause name without interpreting unfamiliar values.

Trait Implementations

`impl Clone for Classification`

impl Clone for Classification

`clone`

fn clone(&self) -> Classification

`clone_from`

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

`impl Debug for Classification`

impl Debug for Classification

`fmt`

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

`impl<'de> Deserialize<'de> for Classification`

impl<'de> Deserialize<'de> for Classification

`deserialize`

fn deserialize<__D>(
    __deserializer: __D,
) -> Result<Classification, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

`impl Hash for Classification`

impl Hash for Classification

`hash`

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

`hash_slice`

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

`impl PartialEq for Classification`

impl PartialEq for Classification

`eq`

fn eq(&self, other: &Classification) -> bool

`ne`

fn ne(&self, other: &Rhs) -> bool

`impl Serialize for Classification`

impl Serialize for Classification

`serialize`

fn serialize<__S>(
    &self,
    __serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

`impl Eq for Classification`

impl Eq for Classification

`impl StructuralPartialEq for Classification`

impl StructuralPartialEq for Classification