Struct edi::InterchangeControl

pub struct InterchangeControl<'a> {

    pub authorization_qualifier: Cow<'a, str>,
    pub authorization_information: Cow<'a, str>,
    pub security_qualifier: Cow<'a, str>,
    pub security_information: Cow<'a, str>,
    pub sender_qualifier: Cow<'a, str>,
    pub sender_id: Cow<'a, str>,
    pub receiver_qualifier: Cow<'a, str>,
    pub receiver_id: Cow<'a, str>,
    pub date: Cow<'a, str>,
    pub time: Cow<'a, str>,
    pub standards_id: Cow<'a, str>,
    pub version: Cow<'a, str>,
    pub interchange_control_number: Cow<'a, str>,
    pub acknowledgement_requested: Cow<'a, str>,
    pub test_indicator: Cow<'a, str>,
    pub functional_groups: VecDeque<FunctionalGroup<'a>>,
}

Represents the ISA/IEA header information commonly known as the “envelope” in X12 EDI.

Fields

authorization_qualifier: Cow<'a, str>

Code to identify the type of information in the Authorization Information.

Qualifiers are two-digit prefixes which categorize the following element.

authorization_information: Cow<'a, str>

Information used for additional identification or authorization of the interchange sender or the data in the interchange; the type of information is set by the Authorization Information Qualifier.

security_qualifier: Cow<'a, str>

Code to identify the type of information in the Security Information

Qualifiers are two-digit prefixes which categorize the following element.

security_information: Cow<'a, str>

This is used for identifying the security information about the interchange sender or the data in the interchange; the type of information is set by the Security Information Qualifier

sender_qualifier: Cow<'a, str>

Qualifier to designate the system/method of code structure used to designate the sender ID.

Qualifiers are two-digit prefixes which categorize the following element.

sender_id: Cow<'a, str>

Identification code published by the sender for other parties to use as the receiver ID to route data to them; the sender always codes this value in the sender ID element

receiver_qualifier: Cow<'a, str>

Qualifier to designate the system/method of code structure used to designate the receiver ID.

Qualifiers are two-digit prefixes which categorize the following element.

receiver_id: Cow<'a, str>

Identification code published by the receiver of the data; When sending, it is used by the sender as their sending ID, thus other parties sending to them will use this as a receiving ID to route data to them

date: Cow<'a, str>

Date of the interchange

time: Cow<'a, str>

Time of the interchange

standards_id: Cow<'a, str>

Code to identify the agency responsible for the control standard used by the message that is enclosed by the interchange header and trailer

version: Cow<'a, str>

Code specifying the version number of the interchange control segments

interchange_control_number: Cow<'a, str>

A control number assigned by the interchange sender

acknowledgement_requested: Cow<'a, str>

Either a 0 or a 1 denoting that acknowledgment is not requested (0) or it is requested (1).

test_indicator: Cow<'a, str>

Code to indicate whether data enclosed by this interchange envelope is test (“T”), production (“P”), or information (“I”).

functional_groups: VecDeque<FunctionalGroup<'a>>

The FunctionalGroups contained in this interchange.

Implementations

impl<'a> InterchangeControl<'a>

pub fn to_x12_string( &self, segment_delimiter: char, element_delimiter: char, sub_element_separator: char, ) -> String

Converts this InterchangeControl into an ANSI x12 string for use in an EDI document.

Trait Implementations

impl<'a> Debug for InterchangeControl<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for InterchangeControl<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for InterchangeControl<'a>

fn eq(&self, other: &InterchangeControl<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for InterchangeControl<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for InterchangeControl<'a>