Struct Any

Source

pub struct Any { /* private fields */ }

Expand description

An refinement of std::any::Any with an associated name (tag) and serialization.

This type represents deserialized inputs returned from crate::Input::try_deserialize and is passed to beckend benchmarks for matching and execution.

Implementations§

Source §

impl Any

Source

pub fn untagged<T>(any: T) -> Self
where T: Serialize + Debug + 'static,

Return a new Any without a tag.

This method exists for examples and testing and generally should not be used.

Users should use crate::Checker::any to construct a properly tagged Any.

Source

pub fn tag(&self) -> &'static str

Return the benchmark tag associated with this benchmarks.

Source

pub fn type_id(&self) -> TypeId

Return the Rust std::any::TypeId for the contained object.

Source

pub fn is<T>(&self) -> bool
where T: Any,

Return true if the runtime value is T. Otherwise, return false.

use diskann_benchmark_runner::any::Any;

let value = Any::untagged(42usize);
assert!(value.is::<usize>());
assert!(!value.is::<u32>());

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Any,

Return a reference to the contained object if it’s runtime type is T.

Otherwise return None.

use diskann_benchmark_runner::any::Any;

let value = Any::untagged(42usize);
assert_eq!(*value.downcast_ref::<usize>().unwrap(), 42);
assert!(value.downcast_ref::<u32>().is_none());

Source

pub fn try_match<'a, T, U>(&'a self) -> Result<MatchScore, FailureScore>
where U: DispatchRule<&'a T>, T: 'static,

Attempt to downcast self to T and if succssful, try matching &T with U using crate::dispatcher::DispatchRule.

Otherwise, return Err(diskann_benchmark_runner::any::MATCH_FAIL).

use diskann_benchmark_runner::{
    any::Any,
    dispatcher::{self, MatchScore, FailureScore},
    utils::datatype::{self, DataType, Type},
};

let value = Any::untagged(DataType::Float32);

// A successful down cast and successful match.
assert_eq!(
    value.try_match::<DataType, Type<f32>>().unwrap(),
    MatchScore(0),
);

// A successful down cast but unsuccessful match.
assert_eq!(
    value.try_match::<DataType, Type<f64>>().unwrap_err(),
    datatype::MATCH_FAIL,
);

// An unsuccessful down cast.
let value = Any::untagged(0usize);
assert_eq!(
    value.try_match::<DataType, Type<f32>>().unwrap_err(),
    diskann_benchmark_runner::any::MATCH_FAIL,
);

Source

pub fn convert<'a, T, U>(&'a self) -> Result
where U: DispatchRule<&'a T>, Error: From<U::Error>, T: 'static,

Attempt to downcast self to T and if succssful, try converting &T with U using crate::dispatcher::DispatchRule.

If unsuccessful, returns an error.

use diskann_benchmark_runner::{
    any::Any,
    dispatcher::{self, MatchScore, FailureScore},
    utils::datatype::{self, DataType, Type},
};

let value = Any::untagged(DataType::Float32);

// A successful down cast and successful conversion.
let _: Type<f32> = value.convert::<DataType, _>().unwrap();

Source

pub fn description<'a, T, U>( f: &mut Formatter<'_>, from: Option<&&'a Self>, tag: impl Display, ) -> Result
where U: DispatchRule<&'a T>, T: 'static,

A wrapper for DispatchRule::description.

If from is None - document the expected tag for the input and return >::description(f, None).

If from is Some - attempt to downcast to T. If successful, return the dispatch rule description for U on the doncast reference. Otherwise, return the expected tag.

use diskann_benchmark_runner::{
    any::Any,
    utils::datatype::{self, DataType, Type},
};

use std::io::Write;

struct Display(Option<Any>);

impl std::fmt::Display for Display {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.0 {
            Some(v) => Any::description::<DataType, Type<f32>>(f, Some(&&v), "my-tag"),
            None => Any::description::<DataType, Type<f32>>(f, None, "my-tag"),
        }
    }
}

// No contained value - document the expected conversion.
assert_eq!(
    Display(None).to_string(),
    "tag \"my-tag\"\nfloat32",
);

// Matching contained value.
assert_eq!(
    Display(Some(Any::untagged(DataType::Float32))).to_string(),
    "successful match",
);

// Successful down cast - unsuccessful match.
assert_eq!(
    Display(Some(Any::untagged(DataType::UInt64))).to_string(),
    "expected \"float32\" but found \"uint64\"",
);

// Unsuccessful down cast.
assert_eq!(
    Display(Some(Any::untagged(0usize))).to_string(),
    "expected tag \"my-tag\" - instead got \"\"",
);