Struct Separators 

pub struct Separators(pub Separators);

A Serde-enabled er7::Separators.

This is the plainest wrapper in the crate: six named, scalar fields, no recursion — the same shape as the Point { x, y } example in serde’s own manual-implementation guide, just with six fields instead of two. Each char serializes through Serializer::serialize_char, which every common format maps to a one-character string.

Example:

use serde_er7::Separators;

let wrapped = Separators(er7::Separators::default());
let json = serde_json::to_string(&wrapped)?;
assert_eq!(
    json,
    r#"{"field":"|","component":"^","repetition":"~","escape":"\\","subcomponent":"&","truncation":null}"#
);

let back: Separators = serde_json::from_str(&json)?;
assert_eq!(back.0, er7::Separators::default());

Tuple Fields

0: Separators

Methods from Deref<Target = Separators>

pub fn validate(&self) -> Result<(), Error>

Check that this set can encode a message unambiguously: no delimiter may be alphanumeric, a carriage return, or a line feed, and no two delimiters may be the same character.

Separators::from_header applies this to every message it reads, because a message that reuses one character for two roles cannot be parsed back into the values the sender meant (R2, spec §3.3).

This is the crate’s only strictness. Everywhere else, odd input is data rather than an error (R6) — but an ambiguous delimiter set would produce confidently wrong values rather than merely ugly ones.

Example:

use er7::Separators;

assert!(Separators::default().validate().is_ok());

// Unusual is fine; ambiguous is not.
let unusual = Separators { field: '#', component: '*', repetition: '!',
                           escape: '?', subcomponent: '@', truncation: None };
assert!(unusual.validate().is_ok());

let repeated = Separators { component: '&', ..Separators::default() };
assert!(repeated.validate().is_err());

let alphanumeric = Separators { field: 'X', ..Separators::default() };
assert!(alphanumeric.validate().is_err());

let terminator = Separators { repetition: '\r', ..Separators::default() };
assert!(terminator.validate().is_err());

Errors

Error::BadHeader naming the offending character, when a delimiter is alphanumeric, is a line ending, or is used for two roles at once (R2, spec §3.3).

pub fn is_delimiter(&self, c: char) -> bool

True when c plays any structural role in this delimiter set.

The truncation character counts, because a message may not reuse it for another role — but note it is not escaped when it appears in a value, since it is structural only inside MSH-2 (spec §6.3).

Example:

use er7::Separators;

let separators = Separators::default();
assert!(separators.is_delimiter('|'));
assert!(separators.is_delimiter('&'));
assert!(!separators.is_delimiter('#'));
assert!(!separators.is_delimiter('A'));

pub fn encoding_characters(&self) -> String

The encoding-characters string this set writes as MSH-2, e.g. ^~\&. Note this excludes the field separator, which is MSH-1.

Example:

use er7::Separators;

assert_eq!(Separators::default().encoding_characters(), r"^~\&");

let v27 = Separators { truncation: Some('#'), ..Separators::default() };
assert_eq!(v27.encoding_characters(), r"^~\&#");

Trait Implementations

impl Clone for Separators

fn clone(&self) -> Separators

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Separators

impl Debug for Separators

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

Formats the value using the given formatter.

impl Default for Separators

fn default() -> Separators

Returns the “default value” for a type.

impl Deref for Separators

type Target = Separators

The resulting type after dereferencing.

fn deref(&self) -> &Separators

Dereferences the value.

impl DerefMut for Separators

fn deref_mut(&mut self) -> &mut Separators

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Separators

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Separators

impl From<Separators> for Separators

fn from(inner: Separators) -> Separators

Converts to this type from the input type.

impl From<Separators> for Separators

fn from(outer: Separators) -> Separators

Converts to this type from the input type.

impl PartialEq for Separators

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Separators

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Separators