Enum Strategy 

pub enum Strategy<S> {
    Broadcast(S),
    Collection(Box<[S]>),
    Indexable(Box<dyn Indexable<S> + Send + Sync>),
}

A dynamic strategy (e.g. diskann::graph::glue::SearchStrategy) manager for built-in searcher such as super::KNN, super::Range, and super::MultiHop.

This provides an efficient means for either broadcasting a single strategy to all search queries, or maintaining a collection of strategies, one for each query.

Variants

Broadcast(S)

Use the same strategy for all queries.

Collection(Box<[S]>)

Use a custom strategy for each query.

Indexable(Box<dyn Indexable<S> + Send + Sync>)

Use a custom strategy for each query via an Indexable trait object.

Implementations

impl<S> Strategy<S>

pub fn broadcast(strategy: S) -> Self

Create a strategy that broadcasts strategy to all queries.

pub fn collection<I>(itr: I) -> Self

where I: IntoIterator<Item = S>,

Create a strategy that uses the strategies in itr for each query.

pub fn from_indexable<I>(indexable: I) -> Self

where S: Debug, I: Indexable<S> + Send + Sync + 'static,

Create a strategy that uses indexable for each query’s strategy.

This method is most useful when the strategies are stored in a custom data structure and can avoid the cost of rematerializing a collection.

pub fn get(&self, index: usize) -> Result<&S, Error>

Get the strategy for the query at index.

pub fn len(&self) -> Option<usize>

Return the number of strategies contained in self, or None if there are an unbounded number of strategies.

use diskann_benchmark_core::search::graph::Strategy;

let strategy = Strategy::broadcast(42usize);
assert_eq!(*strategy.get(0).unwrap(), 42);
assert!(
    strategy.len().is_none(),
    "broadcasted strategies can be retrieved from any index",
);

let strategy = Strategy::collection([42usize, 128usize]);
assert_eq!(*strategy.get(0).unwrap(), 42);
assert_eq!(*strategy.get(1).unwrap(), 128);
assert_eq!(strategy.len(), Some(2));

pub fn is_empty(&self) -> bool

Return true only if the number of strategies is bounded and equal to zero.

pub fn length_compatible( &self, expected: usize, ) -> Result<(), LengthIncompatible>

Check if the number of strategies in self is compatible with expected.

Self::Broadcast is always compatible. Otherwise, the number of strategies must exactly match expected.

Trait Implementations

impl<S: Debug> Debug for Strategy<S>

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

Formats the value using the given formatter.