Struct WithAttributes 

pub struct WithAttributes<T, A> {
    pub attributes: A,
    pub value: T,
}

Wrapper that pairs a value of type T with its associated YSON attributes of type A

Any value can have optional map of attributes

Examples

use ytsaurus_yson::{WithAttributes, from_slice, YsonFormat};
use std::collections::BTreeMap;

// YSON: <author="Alice">"Hello"
let input = b"<author=\"Alice\">\"Hello\"";

// Define a value where attributes are a BTreeMap and the content is a String
type MyNode = WithAttributes<String, BTreeMap<String, String>>;

let node: MyNode = from_slice(input, YsonFormat::Text).unwrap();

// Access attributes
assert_eq!(node.attributes.get("author").unwrap(), "Alice");

// Access inner value directly via Deref or .value
assert_eq!(node.value, "Hello");
assert_eq!(*node, "Hello");

Fields

attributes: A

The attributes associated with the value.

value: T

Data content of the YSON node.

Trait Implementations

impl<T: Clone, A: Clone> Clone for WithAttributes<T, A>

fn clone(&self) -> WithAttributes<T, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, A: Debug> Debug for WithAttributes<T, A>

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

Formats the value using the given formatter.

impl<T: Default, A: Default> Default for WithAttributes<T, A>

fn default() -> WithAttributes<T, A>

Returns the “default value” for a type.

impl<V, A> Deref for WithAttributes<V, A>

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V, A> DerefMut for WithAttributes<V, A>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T, A> Deserialize<'de> for WithAttributes<T, A>

where T: Deserialize<'de>, A: Deserialize<'de>,

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: Eq, A: Eq> Eq for WithAttributes<T, A>

impl<T: PartialEq, A: PartialEq> PartialEq for WithAttributes<T, A>

fn eq(&self, other: &WithAttributes<T, A>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: Serialize, A: Serialize> Serialize for WithAttributes<T, A>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: PartialEq, A: PartialEq> StructuralPartialEq for WithAttributes<T, A>