Struct pica_record::primitives::SubfieldRef

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

An immutable subfield.

Implementations

impl<'a> SubfieldRef<'a>

pub fn new(code: char, value: &'a str) -> Result<Self, ParsePicaError>

Create a new SubfieldRef.

Example

use pica_record::primitives::SubfieldRef;

let subfield = SubfieldRef::new('a', "abc")?;
assert_eq!(subfield.code(), 'a');
assert_eq!(subfield.value(), "abc");

pub fn from_bytes<T: AsRef<[u8]> + ?Sized>( bytes: &'a T, ) -> Result<Self, ParsePicaError>

Creates a new SubfieldRef from a byte slice.

Errors

If an invalid subfield is given, an error is returned.

Example

use pica_record::primitives::SubfieldRef;

let subfield = SubfieldRef::from_bytes(b"\x1f0123456789X")?;
assert_eq!(subfield.code(), '0');
assert_eq!(subfield.value(), "123456789X");

pub fn code(&self) -> &SubfieldCode

Returns the code of the subfield.

Example

use pica_record::primitives::SubfieldRef;

let subfield = SubfieldRef::new('X', "")?;
assert_eq!(subfield.code(), 'X');

pub fn value(&self) -> &SubfieldValueRef<'_>

Returns the value of the subfield.

Example

use pica_record::primitives::SubfieldRef;

let subfield = SubfieldRef::new('a', "abc")?;
assert_eq!(subfield.value(), b"abc");

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

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

Example

use pica_record::primitives::SubfieldRef;

let subfield = SubfieldRef::new('0', "123456789X")?;
assert!(subfield.validate().is_ok());

let subfield = SubfieldRef::from_bytes(&[b'\x1f', b'0', 0, 159])?;
assert_eq!(subfield.validate().is_err(), true);

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

Write the SubfieldRef into the given writer.

Example

use std::io::Cursor;

use pica_record::primitives::SubfieldRef;

let mut writer = Cursor::new(Vec::<u8>::new());
let subfield = SubfieldRef::new('0', "123456789X")?;
subfield.write_to(&mut writer);

assert_eq!(
    String::from_utf8(writer.into_inner())?,
    "\x1f0123456789X"
);

Trait Implementations

impl<'a> Clone for SubfieldRef<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SubfieldRef<'a>

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

Formats the value using the given formatter.

impl From<SubfieldRef<'_>> for Subfield

fn from(subfield: SubfieldRef<'_>) -> Self

Converts a SubfieldRef to a Subfield.

Example

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

let subfield_ref = SubfieldRef::new('0', "123456789X")?;
let subfield = Subfield::from(subfield_ref);
assert_eq!(subfield.code(), '0');
assert_eq!(subfield.value(), "123456789X");

impl<'a> Hash for SubfieldRef<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

fn into_iter(self) -> Self::IntoIter

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

Example

use pica_record::primitives::SubfieldRef;

let subfield = SubfieldRef::new('0', "123456789X")?;
let mut iter = subfield.into_iter();
assert_eq!(iter.next(), Some(&subfield));
assert_eq!(iter.next(), None);

type Item = &'a SubfieldRef<'a>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

impl PartialEq<Subfield> for SubfieldRef<'_>

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

Compare a SubfieldRef with a Subfield.

Example

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

let subfield_ref = SubfieldRef::new('0', "123456789X")?;
let subfield = Subfield::new('0', "123456789X")?;
assert_eq!(subfield_ref, subfield);

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 SubfieldRef<'a>

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

impl<'a> StructuralPartialEq for SubfieldRef<'a>