Struct Field 

pub struct Field(pub Field);

A Serde-enabled er7::Field.

A field is nothing but its repetitions in order (er7::Field::repetitions), so — like Repetition one level down — it serializes as a plain array: 555-1111~555-2222 becomes [["555-1111"], ["555-2222"]]. A field that was sent empty (||) has no repetitions at all, and serializes as []; this is what distinguishes it from a present-but-empty repetition (er7::Field spec).

Example:

use serde_er7::Field;

let message = er7::parse(r"MSH|^~\&|LAB|555-1111~555-2222")?;
let field = message.segment("MSH").unwrap().field(4).unwrap().clone();

let json = serde_json::to_string(&Field(field))?;
let back: Field = serde_json::from_str(&json)?;
assert_eq!(back.to_er7(&message.separators), "555-1111~555-2222");

// Absent (`||`) round-trips as an empty array, not `[[]]`.
let empty: Field = serde_json::from_str("[]")?;
assert!(empty.repetitions.is_empty());

Tuple Fields

0: Field

Methods from Deref<Target = Field>

pub fn repetition(&self, n: usize) -> Option<&Repetition>

The 1-based repetition n, if the message carried one.

Example:

let message = er7::parse("MSH|^~\\&|LAB\rPID|555-1111~555-2222")?;
let phones = message.segment("PID").unwrap().field(1).unwrap();

assert_eq!(phones.repetitions.len(), 2);
assert_eq!(phones.repetition(2).unwrap().to_er7(&message.separators), "555-2222");
assert!(phones.repetition(3).is_none());

pub fn repetition_mut(&mut self, n: usize) -> Option<&mut Repetition>

Mutable access to the 1-based repetition n.

pub fn component(&self, n: usize) -> Option<&Component>

The 1-based component n of the first repetition — the common case, since most fields do not repeat.

Example:

let message = er7::parse("MSH|^~\\&|LAB\rPID|SMITH^JOHN")?;
let name = message.segment("PID").unwrap().field(1).unwrap();

assert_eq!(name.component(1).unwrap().to_er7(&message.separators), "SMITH");

pub fn is_empty(&self) -> bool

True when the field was sent with no repetitions, or with only empty ones. A field holding the explicit null is not empty; see Field::is_null.

pub fn is_null(&self) -> bool

True when this field is exactly the explicit null "", meaning the sender is clearing the stored value.

This is the level the distinction is usually asked at, and getting it wrong is a patient-safety bug: an absent or empty field means “leave the stored value alone”, while a null means “clear it” (R10, R11, spec §5.3).

Example:

let message = er7::parse("MSH|^~\\&|LAB\rPID|1||\"\"|X")?;
let pid = message.segment("PID").unwrap();

// Absent: never sent.
assert!(pid.field(9).is_none());
// Empty: sent as `||`, no value.
assert!(pid.field(2).unwrap().is_empty() && !pid.field(2).unwrap().is_null());
// Null: sent as `""`, clear the stored value.
assert!(pid.field(3).unwrap().is_null() && !pid.field(3).unwrap().is_empty());

pub fn to_er7(&self, separators: &Separators) -> String

Write this field as ER7, exactly as a receiver would read it.

Escape sequences are left intact, so the result can be sent, stored, or parsed again. This is the form the round-trip guarantee applies to (R16).

Example:

let message = er7::parse(r"MSH|^~\&|LAB|Smith \T\ Jones^X")?;
let separators = &message.separators;
let field = message.segment("MSH").unwrap().field(4).unwrap();

assert_eq!(field.to_er7(separators), r"Smith \T\ Jones^X");

pub fn to_text(&self, separators: &Separators) -> String

Write this field with its leaf text escape-decoded.

Structural delimiters remain, so the result shows the shape of the value as well as its content (R17). That also means the result is not re-parseable: a decoded \F\ becomes a literal field separator. Use this for display, logging, and database writes; use to_er7 for anything that goes back into a message.

Example:

let message = er7::parse(r"MSH|^~\&|LAB|Smith \T\ Jones^X")?;
let separators = &message.separators;
let field = message.segment("MSH").unwrap().field(4).unwrap();

// The escape decodes; the component separator stays.
assert_eq!(field.to_text(separators), "Smith & Jones^X");

Trait Implementations

impl Clone for Field

fn clone(&self) -> Field

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Field

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

Formats the value using the given formatter.

impl Default for Field

fn default() -> Field

Returns the “default value” for a type.

impl Deref for Field

type Target = Field

The resulting type after dereferencing.

fn deref(&self) -> &Field

Dereferences the value.

impl DerefMut for Field

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

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Field

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

where D: Deserializer<'de>,

Read an array of repetitions into repetitions.

impl Eq for Field

impl From<Field> for Field

fn from(inner: Field) -> Field

Converts to this type from the input type.

impl From<Field> for Field

fn from(outer: Field) -> Field

Converts to this type from the input type.

impl PartialEq for Field

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Field

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

where S: Serializer,

Write each repetition as one array element. See Component::serialize for the cost of the clone this involves.

impl StructuralPartialEq for Field