Struct pica_record::primitives::RecordRef

pub struct RecordRef<'a>(/* private fields */);

An immutable PICA+ record.

Implementations

impl<'a> RecordRef<'a>

pub fn new<T>( fields: Vec<(&'a str, Option<&'a str>, T)>, ) -> Result<Self, ParsePicaError>

where T: IntoIterator<Item = (char, &'a str)>,

Creates a new RecordRef.

Errors

This function fails if either the tag, occcurrence or any subfield is nvalid.

Example

use pica_record::primitives::RecordRef;

let record = RecordRef::new(vec![
    ("003@", None, vec![('0', "123456789X")]),
    ("002@", None, vec![('0', "Tp1")]),
])?;

assert_eq!(record.fields().len(), 2);

pub fn from_bytes<B>(record: &'a B) -> Result<Self, ParsePicaError>

where B: AsRef<[u8]> + ?Sized,

Creates a new RecordRef from a byte slice.

Example

use pica_record::primitives::RecordRef;

let record = RecordRef::from_bytes(b"012A \x1f0abc\x1e\n")?;
assert_eq!(record.fields().len(), 1);

pub fn fields(&self) -> &[FieldRef<'a>]

Returns the fields of the record.

Example

use pica_record::primitives::{FieldRef, RecordRef};

let record = RecordRef::from_bytes(b"012A \x1f0abc\x1e\n")?;
let field = FieldRef::from_bytes(b"012A \x1f0abc\x1e")?;
assert_eq!(record.fields(), [field]);

pub fn is_empty(&self) -> bool

Returns true if the RecordRef contains no fields, otherwise false.

Example

use pica_record::primitives::RecordRef;

let record = RecordRef::from_bytes(b"002@ \x1f0Oaf\x1e\n")?;
assert!(!record.is_empty());

pub fn retain<F: FnMut(&FieldRef<'_>) -> bool>(&mut self, f: F)

Retains only the FieldRefs specified by the predicate.

Example

use pica_record::primitives::RecordRef;

let mut record = RecordRef::new(vec![
    ("003@", None, vec![('0', "123456789X")]),
    ("002@", None, vec![('0', "Oaf")]),
])?;

assert_eq!(record.fields().len(), 2);

record.retain(|field| field.tag() == "003@");
assert_eq!(record.fields().len(), 1);

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

Returns an std::str::Utf8Error if the record contains invalid UTF-8 data, otherwise the unit.

Example

use pica_record::primitives::RecordRef;

let record = RecordRef::from_bytes(b"003@ \x1f0a\x1e\n")?;
assert!(record.validate().is_ok());

pub fn write_to(&self, out: &mut impl Write) -> Result<()>

Write the RecordRef into the given writer.

Example

use std::io::Cursor;

use pica_record::primitives::RecordRef;

let mut writer = Cursor::new(Vec::<u8>::new());
let record = RecordRef::from_bytes(b"003@ \x1f0a\x1e\n")?;
record.write_to(&mut writer);

assert_eq!(
    String::from_utf8(writer.into_inner())?,
    "003@ \x1f0a\x1e\n"
);

Trait Implementations

impl<'a> Clone for RecordRef<'a>

fn clone(&self) -> RecordRef<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RecordRef<'a>

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

Formats the value using the given formatter.

impl From<RecordRef<'_>> for Record

fn from(record: RecordRef<'_>) -> Self

Converts a RecordRef into a Record.

Example

use pica_record::primitives::{Record, RecordRef};

let record_ref = RecordRef::from_bytes(b"003@ \x1f0a\x1e\n")?;
let record = Record::from(record_ref);
assert_eq!(RecordRef::from_bytes(b"003@ \x1f0a\x1e\n")?, record);

impl<'a> From<RecordRef<'a>> for ByteRecord<'a>

fn from(record: RecordRef<'a>) -> Self

Creates a ByteRecord from a RecordRef.

Example

use pica_record::primitives::RecordRef;
use pica_record::ByteRecord;

let record1 = ByteRecord::from_bytes(b"012A \x1fa123\x1e\n")?;
let record2 = ByteRecord::from(record1);
assert_eq!(record2.fields().len(), 1);

impl PartialEq<Record> for RecordRef<'_>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<RecordRef<'_>> for Record

fn eq(&self, other: &RecordRef<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq for RecordRef<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> StructuralPartialEq for RecordRef<'a>