Struct pica_record::primitives::FieldRef

pub struct FieldRef<'a> { /* private fields */ }

An immutable field.

Implementations

impl<'a> FieldRef<'a>

pub fn new<T>( tag: &'a str, occ: Option<&'a str>, subfields: T, ) -> Result<Self, ParsePicaError>

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

Creates a new FieldRef.

Errors

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

Example

use pica_record::primitives::FieldRef;

let field = FieldRef::new("003@", None, vec![('0', "123456789X")])?;
assert_eq!(field.tag(), "003@");

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

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

Creates an FieldRef from a byte slice.

Errors

This function fails if the given byte slice is not a proper PICA+ field.

use pica_record::primitives::FieldRef;

let field =
    FieldRef::from_bytes(b"003@ \x1f0123456789X\x1e").unwrap();
assert_eq!(field.tag(), "003@");

pub fn tag(&self) -> &TagRef<'a>

Returns a reference to the TagRef of the field.

Example

use pica_record::primitives::FieldRef;

let field = FieldRef::new("003@", None, vec![('0', "123456789X")])?;
assert_eq!(field.tag(), "003@");

pub fn occurrence(&self) -> Option<&OccurrenceRef<'a>>

Returns a reference to the OccurrenceRef of the field.

Example

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

let field =
    FieldRef::new("003@", Some("01"), vec![('0', "123456789X")])?;
assert_eq!(field.occurrence(), Some(&OccurrenceRef::new("01")?));

pub fn subfields(&self) -> &[SubfieldRef<'a>]

Returns a reference to the SubfieldRefs of the field.

Example

use pica_record::primitives::FieldRef;

let field = FieldRef::new("003@", None, vec![('0', "123456789X")])?;
let subfields = field.subfields();
assert_eq!(subfields.len(), 1);

pub fn contains(&self, code: char) -> bool

Checks whether a FieldRef contains a SubfieldRef with the given code or not.

Example

use pica_record::primitives::FieldRef;

let field = FieldRef::new("003@", None, vec![('0', "123456789X")])?;
assert!(!field.contains('a'));
assert!(field.contains('0'));

pub fn find<F>(&self, predicate: F) -> Option<&SubfieldRef<'_>>

where F: Fn(&&SubfieldRef<'_>) -> bool,

Searches for the first SubfieldRef that satisfies the given predicate.

Example

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

let field =
    FieldRef::new("012A", None, vec![('a', "b"), ('c', "d")])?;

assert!(field.find(|subfield| subfield.code() == 'b').is_none());

let subfield =
    field.find(|subfield| subfield.code() == 'a').unwrap();
assert_eq!(subfield, &SubfieldRef::new('a', "b")?);

pub fn level(&self) -> Level

Returns the level of the field.

Example

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

let field = FieldRef::from_bytes(b"012A/01 \x1fab\x1fcd\x1e")?;
assert_eq!(field.level(), Level::Main);

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

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

Example

use pica_record::primitives::FieldRef;

let field = FieldRef::from_bytes(b"003@ \x1f0123\x1e")?;
assert!(field.validate().is_ok());

let field = FieldRef::from_bytes(b"003@ \x1f0\x00\x9F\x1e")?;
assert!(field.validate().is_err());

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

Write the FieldRef into the given writer.

Example

use std::io::Cursor;

use pica_record::primitives::FieldRef;

let mut writer = Cursor::new(Vec::<u8>::new());
let field = FieldRef::from_bytes(b"012A/01 \x1fab\x1fcd\x1e")?;
field.write_to(&mut writer);

assert_eq!(
    String::from_utf8(writer.into_inner())?,
    "012A/01 \x1fab\x1fcd\x1e"
);

Trait Implementations

impl<'a> Clone for FieldRef<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for FieldRef<'a>

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

Formats the value using the given formatter.

impl From<FieldRef<'_>> for Field

fn from(field: FieldRef<'_>) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a FieldRef<'a>

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a single field. The iterator just returns the field once.

Example

use pica_record::primitives::FieldRef;

let field = FieldRef::new("003@", None, vec![('0', "abc")])?;
let mut iter = field.into_iter();

assert_eq!(iter.next(), Some(&field));
assert_eq!(iter.next(), None);

type Item = &'a FieldRef<'a>

The type of the elements being iterated over.

type IntoIter = Once<<&'a FieldRef<'a> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

impl PartialEq<Field> for FieldRef<'_>

fn eq(&self, field: &Field) -> 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<FieldRef<'_>> for Field

fn eq(&self, other: &FieldRef<'_>) -> 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 FieldRef<'a>

fn eq(&self, other: &FieldRef<'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> Eq for FieldRef<'a>

impl<'a> StructuralPartialEq for FieldRef<'a>