Struct pica_record::primitives::TagRef

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

An immutable tag.

Implementations

impl<'a> TagRef<'a>

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

Create a new TagRef from a string slice.

Panics

This method panics if the tag is invalid.

Example

use pica_record::primitives::TagRef;

let tag = TagRef::new("003@")?;
assert_eq!(tag, "003@");

pub fn from_unchecked<T: AsRef<[u8]> + ?Sized>(tag: &'a T) -> Self

Creates a new TagRef without checking for validity.

Safety

The caller must ensure that the given tag is valid.

Example

use pica_record::primitives::TagRef;

let tag = TagRef::from_unchecked(b"004A");
assert_eq!(tag, "004A");

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

Create a new TagRef from a byte slice.

Panics

This method panics if the tag is invalid.

Example

use pica_record::primitives::TagRef;

let tag = TagRef::from_bytes(b"003@")?;
assert_eq!(tag, "003@");

pub fn level(&self) -> Level

Returns the Level of the TagRef.

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

assert_eq!(TagRef::new("003@")?.level(), Level::Main);
assert_eq!(TagRef::new("101@")?.level(), Level::Local);
assert_eq!(TagRef::new("203@")?.level(), Level::Copy);

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

Write the TagRef into the given writer.

Example

use std::io::Cursor;

use pica_record::primitives::TagRef;

let mut writer = Cursor::new(Vec::<u8>::new());
let tag = TagRef::new("003@")?;
tag.write_to(&mut writer);

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

Trait Implementations

impl<'a> Clone for TagRef<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TagRef<'a>

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

Formats the value using the given formatter.

impl From<TagRef<'_>> for Tag

fn from(tag: TagRef<'_>) -> Self

Create a new Tag from a TagRef.

Example

use pica_record::primitives::{Tag, TagRef};

let tag_ref = TagRef::new("003@")?;
let tag = Tag::from(tag_ref);
assert_eq!(tag, "003@");

impl Index<usize> for TagRef<'_>

fn index(&self, index: usize) -> &Self::Output

Access certain positions (indexed from zero) of a TagRef.

Panics

This functions panics of the position is greater than three.

Example

use pica_record::primitives::TagRef;

let tag = TagRef::new("003@")?;
assert_eq!(tag[0], b'0');
assert_eq!(tag[1], b'0');
assert_eq!(tag[2], b'3');
assert_eq!(tag[3], b'@');

type Output = u8

The returned type after indexing.

impl PartialEq<&str> for &TagRef<'_>

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

Compare a TagRef reference with a string slice.

Example

use pica_record::primitives::TagRef;

let tag = TagRef::new("003@")?;
assert_eq!(&tag, "003@");

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<&str> for TagRef<'_>

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

Compare a TagRef with a string slice.

Example

use pica_record::primitives::TagRef;

let tag = TagRef::new("003@")?;
assert_eq!(tag, "003@");

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<Tag> for TagRef<'_>

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

Compares a TagRef with a Tag.

Example

use pica_record::primitives::{Tag, TagRef};

let tag_ref = Tag::new("003@")?;
let tag = Tag::new("003@")?;
assert_eq!(tag_ref, tag);

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<TagRef<'_>> for Tag

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

Compares a Tag with a TagRef.

Example

use pica_record::primitives::{Tag, TagRef};

let tag = Tag::new("003@")?;
let tag_ref = Tag::new("003@")?;
assert_eq!(tag, tag_ref);

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

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

impl<'a> StructuralPartialEq for TagRef<'a>