Struct Annotations 

pub struct Annotations { /* private fields */ }

An ordered sequence of symbols that convey additional, application-specific information about their associated Ion value.

The IntoAnnotations trait is a convenient way to convert collections of symbol convertible things (including &str and String) into this sequence.

use ion_rs::{Annotations, IntoAnnotations};
let annotations: Annotations = ["foo", "bar", "baz"].into_annotations();
for annotation in &annotations {
    assert_eq!(annotation.text().map(|s| s.len()), Some(3));
}

Implementations

impl Annotations

pub fn empty() -> Self

Constructs an Annotations object representing an empty symbol sequence

pub fn iter(&self) -> SymbolsIterator<'_>

Returns an Iterator that yields each of the Symbols in this annotations sequence in order.

pub fn len(&self) -> usize

Returns the number of annotations in this sequence.

use ion_rs::{Annotations, IntoAnnotations};
let annotations: Annotations = ["foo", "bar", "baz"].into_annotations();
assert_eq!(annotations.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if this sequence contains zero annotations. Otherwise, returns false.

use ion_rs::{Annotations, IntoAnnotations};
let annotations: Annotations = ["foo", "bar", "baz"].into_annotations();
assert!(!annotations.is_empty());

pub fn contains<S: AsRef<str>>(&self, query: S) -> bool

Returns true if any symbol in this annotations sequence is equal to the provided text. Otherwise, returns false.

use ion_rs::{Annotations, IntoAnnotations};
let annotations: Annotations = ["foo", "bar", "baz"].into_annotations();
assert!(annotations.contains("foo"));
assert!(annotations.contains("bar"));
assert!(annotations.contains("baz"));

assert!(!annotations.contains("quux"));
assert!(!annotations.contains("quuz"));

pub fn first(&self) -> Option<&str>

Returns the text of the first annotation in this sequence.

If the sequence is empty, returns None. If the first annotation in the sequence is $0 (symbol ID 0), returns None. Otherwise, returns a Some(&str) containing the text.

To view the first annotation as a Symbol rather than a &str, use annotations.iter().next().

use ion_rs::{Annotations, IntoAnnotations};
use ion_rs::Symbol;
let annotations: Annotations = ["foo", "bar", "baz"].into_annotations();
assert_eq!(annotations.first(), Some("foo"));

let empty_sequence: Vec<&str> = vec![];
let annotations: Annotations = empty_sequence.into_annotations();
assert_eq!(annotations.first(), None);

let annotations: Annotations = [Symbol::unknown_text()].into_annotations();
assert_eq!(annotations.first(), None)

Trait Implementations

impl AsRef<[Symbol]> for Annotations

fn as_ref(&self) -> &[Symbol]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Annotations

fn clone(&self) -> Annotations

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Annotations

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

Formats the value using the given formatter.

impl Eq for Annotations

impl From<Vec<Symbol>> for Annotations

fn from(value: Vec<Symbol>) -> Self

Converts to this type from the input type.

impl<S: Into<Symbol>> FromIterator<S> for Annotations

fn from_iter<T: IntoIterator<Item = S>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Annotations

type Item = &'a Symbol

The type of the elements being iterated over.

type IntoIter = SymbolsIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Annotations

type Item = Symbol

The type of the elements being iterated over.

type IntoIter = AnnotationsIntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Annotations

fn eq(&self, other: &Annotations) -> 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 StructuralPartialEq for Annotations