Enum StoreEntry 

pub enum StoreEntry {
    Var {
        value: Value,
        ty: Type,
    },
    Array(Vec<StoreEntry>),
    Map(HashMap<String, StoreEntry>),
}

The generic entry type held by the runtime Store.

A StoreEntry is one of three shapes: a scalar Var pairing a Value with its Type, an Array of nested entries, or a Map of named nested entries. This union is what lets the store hold variables, collection handles, step outputs, and resolved parameters uniformly.

The get_* methods (taking a key or index) traverse collection entries and fail with an AccessError when the entry has the wrong shape. The as_* methods narrow an entry to a specific variant for callers that know what they are holding.

Variants

Var

A scalar value paired with its type tag.

Fields

value: Value

The stored value.

ty: Type

The type tag derived from value at insertion time.

Array(Vec<StoreEntry>)

An ordered array of nested entries.

Map(HashMap<String, StoreEntry>)

A map of named nested entries.

Implementations

impl StoreEntry

pub fn get_key(&self, key: &str) -> Result<&StoreEntry, AccessError>

Looks up a child entry by key. Fails with AccessError::NotAMap if this entry is not a Map, or AccessError::NotFound if the key is missing.

Examples found in repository

examples/extend_store_nested.rs (line 104)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // An Operation would call these to populate its output Store.
    write_query_results(&mut store)?;
    write_grouped_data(&mut store)?;
    write_nested_config(&mut store)?;

    // --- Reading results back via chained accessors ---

    // Query rows: array -> index -> key -> value
    let bob_status = store
        .get("rows")?
        .get_index(1)?
        .get_key("status")?
        .get_value()?;
    println!("rows[1].status = {bob_status:?}");
    assert_eq!(bob_status, &Value::Text("Failure".into()));

    let alice_attempts = store
        .get("rows")?
        .get_index(0)?
        .get_key("attempts")?
        .get_value()?;
    println!("rows[0].attempts = {alice_attempts:?}");
    assert_eq!(alice_attempts, &Value::Integer(1));

    // Grouped data: map -> key -> index -> value
    let high_count = store.get("by_severity")?.get_key("high")?.as_array()?.len();
    println!("by_severity.high: {high_count} incidents");
    assert_eq!(high_count, 2);

    let first_low = store
        .get("by_severity")?
        .get_key("low")?
        .get_index(0)?
        .get_value()?;
    println!("by_severity.low[0] = {first_low:?}");

    // Nested config: map -> key -> key -> key -> value
    let timeout = store
        .get("pipeline_config")?
        .get_key("source")?
        .get_key("options")?
        .get_key("timeout_secs")?
        .get_value()?;
    println!("pipeline_config.source.options.timeout_secs = {timeout:?}");
    assert_eq!(timeout, &Value::Integer(30));

    // Config outputs array: map -> key -> index -> key -> value
    let second_format = store
        .get("pipeline_config")?
        .get_key("outputs")?
        .get_index(1)?
        .get_key("format")?
        .get_value()?;
    println!("pipeline_config.outputs[1].format = {second_format:?}");
    assert_eq!(second_format, &Value::Text("csv".into()));

    println!("store_nested: ok");
    Ok(())
}

examples/extend_store_collections.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn get_index(&self, index: usize) -> Result<&StoreEntry, AccessError>

Looks up a child entry by index. Fails with AccessError::NotAnArray if this entry is not an Array, or AccessError::IndexOutOfBounds if the index is out of range.

Examples found in repository

examples/extend_store_nested.rs (line 103)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // An Operation would call these to populate its output Store.
    write_query_results(&mut store)?;
    write_grouped_data(&mut store)?;
    write_nested_config(&mut store)?;

    // --- Reading results back via chained accessors ---

    // Query rows: array -> index -> key -> value
    let bob_status = store
        .get("rows")?
        .get_index(1)?
        .get_key("status")?
        .get_value()?;
    println!("rows[1].status = {bob_status:?}");
    assert_eq!(bob_status, &Value::Text("Failure".into()));

    let alice_attempts = store
        .get("rows")?
        .get_index(0)?
        .get_key("attempts")?
        .get_value()?;
    println!("rows[0].attempts = {alice_attempts:?}");
    assert_eq!(alice_attempts, &Value::Integer(1));

    // Grouped data: map -> key -> index -> value
    let high_count = store.get("by_severity")?.get_key("high")?.as_array()?.len();
    println!("by_severity.high: {high_count} incidents");
    assert_eq!(high_count, 2);

    let first_low = store
        .get("by_severity")?
        .get_key("low")?
        .get_index(0)?
        .get_value()?;
    println!("by_severity.low[0] = {first_low:?}");

    // Nested config: map -> key -> key -> key -> value
    let timeout = store
        .get("pipeline_config")?
        .get_key("source")?
        .get_key("options")?
        .get_key("timeout_secs")?
        .get_value()?;
    println!("pipeline_config.source.options.timeout_secs = {timeout:?}");
    assert_eq!(timeout, &Value::Integer(30));

    // Config outputs array: map -> key -> index -> key -> value
    let second_format = store
        .get("pipeline_config")?
        .get_key("outputs")?
        .get_index(1)?
        .get_key("format")?
        .get_value()?;
    println!("pipeline_config.outputs[1].format = {second_format:?}");
    assert_eq!(second_format, &Value::Text("csv".into()));

    println!("store_nested: ok");
    Ok(())
}

examples/extend_store_collections.rs (line 90)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn get_value(&self) -> Result<&Value, AccessError>

Returns the inner Value of a Var entry. Fails with AccessError::NotAVar for arrays or maps.

Examples found in repository

examples/extend_store_scalars.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // define_var accepts any V: Into<Value>.
    // From impls exist for &str, String, bool, i64, f64, so you can pass
    // these directly without calling .into().
    store.define_var("name", "Alice")?;
    store.define_var("age", 30i64)?;
    store.define_var("active", true)?;
    store.define_var("score", 9.5f64)?;
    store.define_var("empty", Value::Null)?;

    // Reading back: Store::get returns &StoreEntry.
    // get_value() extracts the &Value from a Var entry.
    let name = store.get("name")?.get_value()?;
    println!("name = {name:?}");

    // as_var() returns (&Value, &Type) — useful when you need to inspect both.
    let (val, ty) = store.get("age")?.as_var()?;
    println!("age = {val:?} (type: {ty:?})");

    // Type is inferred from the value at define time.
    assert_eq!(store.get("active")?.as_var()?.1, &Type::Boolean);
    assert_eq!(store.get("score")?.as_var()?.1, &Type::Float);
    assert_eq!(store.get("empty")?.as_var()?.1, &Type::Null);

    // Duplicate names are rejected with StoreError::EntryAlreadyExists.
    let err = store.define_var("name", "Bob");
    println!("duplicate define_var: {err:?}");
    assert!(err.is_err());

    println!("store_scalars: ok");
    Ok(())
}

examples/extend_store_nested.rs (line 105)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // An Operation would call these to populate its output Store.
    write_query_results(&mut store)?;
    write_grouped_data(&mut store)?;
    write_nested_config(&mut store)?;

    // --- Reading results back via chained accessors ---

    // Query rows: array -> index -> key -> value
    let bob_status = store
        .get("rows")?
        .get_index(1)?
        .get_key("status")?
        .get_value()?;
    println!("rows[1].status = {bob_status:?}");
    assert_eq!(bob_status, &Value::Text("Failure".into()));

    let alice_attempts = store
        .get("rows")?
        .get_index(0)?
        .get_key("attempts")?
        .get_value()?;
    println!("rows[0].attempts = {alice_attempts:?}");
    assert_eq!(alice_attempts, &Value::Integer(1));

    // Grouped data: map -> key -> index -> value
    let high_count = store.get("by_severity")?.get_key("high")?.as_array()?.len();
    println!("by_severity.high: {high_count} incidents");
    assert_eq!(high_count, 2);

    let first_low = store
        .get("by_severity")?
        .get_key("low")?
        .get_index(0)?
        .get_value()?;
    println!("by_severity.low[0] = {first_low:?}");

    // Nested config: map -> key -> key -> key -> value
    let timeout = store
        .get("pipeline_config")?
        .get_key("source")?
        .get_key("options")?
        .get_key("timeout_secs")?
        .get_value()?;
    println!("pipeline_config.source.options.timeout_secs = {timeout:?}");
    assert_eq!(timeout, &Value::Integer(30));

    // Config outputs array: map -> key -> index -> key -> value
    let second_format = store
        .get("pipeline_config")?
        .get_key("outputs")?
        .get_index(1)?
        .get_key("format")?
        .get_value()?;
    println!("pipeline_config.outputs[1].format = {second_format:?}");
    assert_eq!(second_format, &Value::Text("csv".into()));

    println!("store_nested: ok");
    Ok(())
}

examples/extend_store_collections.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn as_var(&self) -> Result<(&Value, &Type), AccessError>

Narrows this entry to a Var, returning its value and type. Fails with AccessError::NotAVar for arrays or maps.

Examples found in repository

examples/extend_store_scalars.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // define_var accepts any V: Into<Value>.
    // From impls exist for &str, String, bool, i64, f64, so you can pass
    // these directly without calling .into().
    store.define_var("name", "Alice")?;
    store.define_var("age", 30i64)?;
    store.define_var("active", true)?;
    store.define_var("score", 9.5f64)?;
    store.define_var("empty", Value::Null)?;

    // Reading back: Store::get returns &StoreEntry.
    // get_value() extracts the &Value from a Var entry.
    let name = store.get("name")?.get_value()?;
    println!("name = {name:?}");

    // as_var() returns (&Value, &Type) — useful when you need to inspect both.
    let (val, ty) = store.get("age")?.as_var()?;
    println!("age = {val:?} (type: {ty:?})");

    // Type is inferred from the value at define time.
    assert_eq!(store.get("active")?.as_var()?.1, &Type::Boolean);
    assert_eq!(store.get("score")?.as_var()?.1, &Type::Float);
    assert_eq!(store.get("empty")?.as_var()?.1, &Type::Null);

    // Duplicate names are rejected with StoreError::EntryAlreadyExists.
    let err = store.define_var("name", "Bob");
    println!("duplicate define_var: {err:?}");
    assert!(err.is_err());

    println!("store_scalars: ok");
    Ok(())
}

pub fn as_array(&self) -> Result<&Vec<StoreEntry>, AccessError>

Narrows this entry to an Array, returning the underlying vector. Fails with AccessError::NotAnArray for vars or maps.

Examples found in repository

examples/extend_store_nested.rs (line 118)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // An Operation would call these to populate its output Store.
    write_query_results(&mut store)?;
    write_grouped_data(&mut store)?;
    write_nested_config(&mut store)?;

    // --- Reading results back via chained accessors ---

    // Query rows: array -> index -> key -> value
    let bob_status = store
        .get("rows")?
        .get_index(1)?
        .get_key("status")?
        .get_value()?;
    println!("rows[1].status = {bob_status:?}");
    assert_eq!(bob_status, &Value::Text("Failure".into()));

    let alice_attempts = store
        .get("rows")?
        .get_index(0)?
        .get_key("attempts")?
        .get_value()?;
    println!("rows[0].attempts = {alice_attempts:?}");
    assert_eq!(alice_attempts, &Value::Integer(1));

    // Grouped data: map -> key -> index -> value
    let high_count = store.get("by_severity")?.get_key("high")?.as_array()?.len();
    println!("by_severity.high: {high_count} incidents");
    assert_eq!(high_count, 2);

    let first_low = store
        .get("by_severity")?
        .get_key("low")?
        .get_index(0)?
        .get_value()?;
    println!("by_severity.low[0] = {first_low:?}");

    // Nested config: map -> key -> key -> key -> value
    let timeout = store
        .get("pipeline_config")?
        .get_key("source")?
        .get_key("options")?
        .get_key("timeout_secs")?
        .get_value()?;
    println!("pipeline_config.source.options.timeout_secs = {timeout:?}");
    assert_eq!(timeout, &Value::Integer(30));

    // Config outputs array: map -> key -> index -> key -> value
    let second_format = store
        .get("pipeline_config")?
        .get_key("outputs")?
        .get_index(1)?
        .get_key("format")?
        .get_value()?;
    println!("pipeline_config.outputs[1].format = {second_format:?}");
    assert_eq!(second_format, &Value::Text("csv".into()));

    println!("store_nested: ok");
    Ok(())
}

examples/extend_store_collections.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn as_map(&self) -> Result<&HashMap<String, StoreEntry>, AccessError>

Narrows this entry to a Map, returning the underlying hash map. Fails with AccessError::NotAMap for vars or arrays.

Trait Implementations

impl Clone for StoreEntry

fn clone(&self) -> StoreEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StoreEntry

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

Formats the value using the given formatter.

impl From<&Value> for StoreEntry

fn from(v: &Value) -> Self

Converts to this type from the input type.

impl<T: Into<Value>> From<T> for StoreEntry

fn from(v: T) -> Self

Converts to this type from the input type.

impl From<Vec<StoreEntry>> for StoreEntry

fn from(items: Vec<StoreEntry>) -> Self

Converts to this type from the input type.

impl Hash for StoreEntry

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StoreEntry

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

impl StructuralPartialEq for StoreEntry