Struct ion_rs::IonData

pub struct IonData<T>(_);

A wrapper for lifting Ion compatible data into using Ion-oriented comparisons (versus the Rust value semantics). This enables the default semantics to be what a Rust user expects for native values, but allows a user to opt-in to Ion’s structural equivalence/order.

Equivalence with respect to Ion values means that if two Ion values, X and Y, are equivalent, they represent the same data and can be substituted for the other without loss of information.

Some types, such as Element and Value cannot be used as the key of a map because they adhere to Rust value semantics—these types cannot implement Eq because they include NaN as a possible value.

For use cases that are concerned with preserving the original Ion data, it is necessary to use Ion value equivalence. Many common use cases, such as writing unit tests for code that produces Ion, can be handled with IonData::eq().

For other use cases, such as using Ion data as the key of a map or passing Ion data to an algorithm that depends on Eq, you can lift values using IonData::from().

Generally, anything that is treated as Ion data (e.g., Element and Value), can be converted to IonData.

Hash and Ord are not guaranteed to be implemented for all IonData, but when they are, they are required to be consistent with Ion structural equality (and Eq).

WARNING—The Ion specification does not define a total ordering over all Ion values. Do not depend on getting any particular result from Ord. Use it only as an opaque total ordering over all IonData. The algorithm used for Ord may change between versions.

Implementations

impl<T: IonEq> IonData<T>

pub fn eq<R: Deref<Target = T>>(a: R, b: R) -> bool

Checks if two values are equal according to Ion’s structural equivalence.

pub fn into_inner(self) -> T

Unwraps the value.

Trait Implementations

impl<T: IonEq> AsRef<T> for IonData<T>

fn as_ref(&self) -> &T

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

impl<T: Clone> Clone for IonData<T>

fn clone(&self) -> IonData<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for IonData<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for IonData<T>

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

Formats the value using the given formatter.

impl<T: IonEq> From<T> for IonData<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: IonEq + IonOrd> Ord for IonData<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: IonEq> PartialEq<IonData<T>> for IonData<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: IonEq + IonOrd> PartialOrd<IonData<T>> for IonData<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: IonEq> Eq for IonData<T>