Struct Xs 

pub struct Xs { /* private fields */ }

Collection of named tensors with associated images and texts.

Implementations

impl Xs

pub fn with_map(self, x: HashMap<String, X>) -> Self

Sets the map field.

Arguments

• x - The new value to be assigned

Returns

Returns Self for method chaining.

Example

let obj = Xs::default().with_map(value);

---

Generated by aksr - Builder pattern macro

pub fn map(&self) -> &HashMap<String, X>

Returns a reference to the map field.

Example

let obj = Xs::default();
let value = obj.map();

---

Generated by aksr - Builder pattern macro

pub fn into_map(self) -> HashMap<String, X>

Consumes self and returns the map field.

This method moves the owned value out of the struct without cloning.

Returns

Returns the owned value of type HashMap < String, X >.

Example

let obj = Xs::default().with_map(value);
let value = obj.into_map();
// obj is now consumed and cannot be used

---

Generated by aksr - Builder pattern macro

pub fn take_map(&mut self) -> HashMap<String, X>

where HashMap<String, X>: Default,

Takes the map field and replaces it with Default::default().

This method moves the value out and replaces it with the default value, allowing you to continue using the struct.

Returns

Returns the owned value of type HashMap < String, X >.

Note

Requires the field type HashMap < String, X > to implement Default. Prefer this when you want to keep using the instance.

Example

let mut obj = Xs::default().with_map(value);
let value = obj.take_map();
// obj.map is now set to Default::default()

---

Generated by aksr - Builder pattern macro

pub fn with_names(self, x: &[&str]) -> Self

Sets the names field from a slice of string slices.

Arguments

• x - A slice of string slices that will be automatically converted to Vec<String>

Returns

Returns Self for method chaining.

Note

If the slice is empty, the field remains unchanged.

Example

let obj = Xs::default().with_names(&["str1", "str2"]);

---

Generated by aksr - Builder pattern macro

pub fn with_names_owned(self, x: &[String]) -> Self

Sets the names field from a slice of owned strings.

Arguments

• x - A slice of String to be cloned into the vector

Returns

Returns Self for method chaining.

Note

This method is useful when you already have a Vec<String> and want to avoid converting to &[&str]. If the slice is empty, the field remains unchanged.

Example

let strings = vec![String::from("a"), String::from("b")];
let obj = Xs::default().with_names_owned(&strings);

---

Generated by aksr - Builder pattern macro

pub fn names(&self) -> &[String]

Returns a slice view of the names field.

Example

let obj = Xs::default();
let items = obj.names();

---

Generated by aksr - Builder pattern macro

pub fn into_names(self) -> Vec<String>

Consumes self and returns the names field.

This method moves the owned value out of the struct without cloning.

Returns

Returns the owned value of type Vec < String >.

Example

let obj = Xs::default().with_names(value);
let value = obj.into_names();
// obj is now consumed and cannot be used

---

Generated by aksr - Builder pattern macro

pub fn take_names(&mut self) -> Vec<String>

where Vec<String>: Default,

Takes the names field and replaces it with Default::default().

This method moves the value out and replaces it with the default value, allowing you to continue using the struct.

Returns

Returns the owned value of type Vec < String >.

Note

Requires the field type Vec < String > to implement Default. Prefer this when you want to keep using the instance.

Example

let mut obj = Xs::default().with_names(value);
let value = obj.take_names();
// obj.names is now set to Default::default()

---

Generated by aksr - Builder pattern macro

impl Xs

pub fn new() -> Self

pub fn derive(&self) -> Self

pub fn push(&mut self, value: X)

pub fn push_kv(&mut self, key: &str, value: X) -> Result<()>

Methods from Deref<Target = HashMap<String, X>>

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

This number is a lower bound; the HashMap<K, V> might be able to hold more, but is guaranteed to be able to hold at least this many.

Examples

use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

Examples

use std::collections::HashMap;

let map: HashMap<&str, i32> = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

let mut values: Vec<_> = map.keys().copied().collect();
values.sort();

assert_eq!(values, vec!["a", "b", "c"]);

Performance

In the current implementation, iterating over keys takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

Examples

use std::collections::HashMap;

let map: HashMap<&str, i32> = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

let mut values: Vec<_> = map.values().copied().collect();
values.sort();

assert_eq!(values, vec![1, 2, 3]);

Performance

In the current implementation, iterating over values takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

Examples

use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

let mut count = 0;

for (_key, _val) in map.iter() {
    count += 1;
}

assert_eq!(count, 3);

Performance

In the current implementation, iterating over map takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use std::collections::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use std::collections::HashMap;

let mut a = HashMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

Examples

use std::collections::HashMap;
use std::hash::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns the key-value pair corresponding to the supplied key. This is potentially useful:

• for key types where non-identical keys can be considered equal;
• for getting the &K stored key value from a borrowed &Q lookup key; or
• for getting a reference to a key with the same lifetime as the collection.

The supplied key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;
use std::hash::{Hash, Hasher};

#[derive(Clone, Copy, Debug)]
struct S {
    id: u32,
    name: &'static str, // ignored by equality and hashing operations
}

impl PartialEq for S {
    fn eq(&self, other: &S) -> bool {
        self.id == other.id
    }
}

impl Eq for S {}

impl Hash for S {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

let j_a = S { id: 1, name: "Jessica" };
let j_b = S { id: 1, name: "Jess" };
let p = S { id: 2, name: "Paul" };
assert_eq!(j_a, j_b);

let mut map = HashMap::new();
map.insert(j_a, "Paris");
assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));
assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case
assert_eq!(map.get_key_value(&p), None);

pub fn contains_key<Q>(&self, k: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

Trait Implementations

impl Clone for Xs

fn clone(&self) -> Xs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Xs

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

Formats the value using the given formatter.

impl Default for Xs

fn default() -> Xs

Returns the “default value” for a type.

impl Deref for Xs

type Target = HashMap<String, X>

The resulting type after dereferencing.

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

Dereferences the value.

impl From<Vec<X>> for Xs

fn from(xs: Vec<X>) -> Self

Converts to this type from the input type.

impl From<X> for Xs

fn from(x: X) -> Self

Converts to this type from the input type.

impl Index<&str> for Xs

type Output = X

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<usize> for Xs

type Output = X

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Xs

type Item = &'a X

The type of the elements being iterated over.

type IntoIter = XsIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.