Struct PuzzleSolutions

pub struct PuzzleSolutions<N: Network> { /* private fields */ }

The individual solutions.

Implementations

impl<N: Network> PuzzleSolutions<N>

pub fn new(solutions: Vec<Solution<N>>) -> Result<Self>

Initializes a new instance of the solutions.

pub fn solution_ids(&self) -> impl '_ + Iterator<Item = &SolutionID<N>>

Returns the solution IDs.

pub fn len(&self) -> usize

Returns the number of solutions.

pub fn is_empty(&self) -> bool

Returns true if there are no solutions.

pub fn get_solution(&self, solution_id: &SolutionID<N>) -> Option<&Solution<N>>

Returns the solution for the given solution ID.

pub fn to_accumulator_point(&self) -> Result<Field<N>>

Returns the accumulator challenge point.

Methods from Deref<Target = IndexMap<SolutionID<N>, Solution<N>>>

pub fn capacity(&self) -> usize

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

This number is a lower bound; the map might be able to hold more, but is guaranteed to be able to hold at least this many.

Computes in O(1) time.

pub fn hasher(&self) -> &S

Return a reference to the map’s BuildHasher.

pub fn len(&self) -> usize

Return the number of key-value pairs in the map.

Computes in O(1) time.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Computes in O(1) time.

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

Return an iterator over the key-value pairs of the map, in their order

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

Return an iterator over the keys of the map, in their order

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

Return an iterator over the values of the map, in their order

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

where Q: Hash + Equivalent<K> + ?Sized,

Return true if an equivalent to key exists in the map.

Computes in O(1) time (average).

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

where Q: Hash + Equivalent<K> + ?Sized,

Return a reference to the value stored for key, if it is present, else None.

Computes in O(1) time (average).

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

where Q: Hash + Equivalent<K> + ?Sized,

Return references to the key-value pair stored for key, if it is present, else None.

Computes in O(1) time (average).

pub fn get_full<Q>(&self, key: &Q) -> Option<(usize, &K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Return item index, key and value

pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>

where Q: Hash + Equivalent<K> + ?Sized,

Return item index, if it exists in the map

Computes in O(1) time (average).

pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>

where K: Ord,

Search over a sorted map for a key.

Returns the position where that key is present, or the position where it can be inserted to maintain the sort. See slice::binary_search for more details.

Computes in O(log(n)) time, which is notably less scalable than looking the key up using get_index_of, but this can also position missing keys.

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> Ordering,

Search over a sorted map with a comparator function.

Returns the position where that value is present, or the position where it can be inserted to maintain the sort. See slice::binary_search_by for more details.

Computes in O(log(n)) time.

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F, ) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> B, B: Ord,

Search over a sorted map with an extraction function.

Returns the position where that value is present, or the position where it can be inserted to maintain the sort. See slice::binary_search_by_key for more details.

Computes in O(log(n)) time.

pub fn partition_point<P>(&self, pred: P) -> usize

where P: FnMut(&K, &V) -> bool,

Returns the index of the partition point of a sorted map according to the given predicate (the index of the first element of the second partition).

See slice::partition_point for more details.

Computes in O(log(n)) time.

pub fn as_slice(&self) -> &Slice<K, V>

Returns a slice of all the key-value pairs in the map.

Computes in O(1) time.

pub fn get_index(&self, index: usize) -> Option<(&K, &V)>

Get a key-value pair by index

Valid indices are 0 <= index < self.len().

Computes in O(1) time.

pub fn get_range<R>(&self, range: R) -> Option<&Slice<K, V>>

where R: RangeBounds<usize>,

Returns a slice of key-value pairs in the given range of indices.

Valid indices are 0 <= index < self.len().

Computes in O(1) time.

pub fn first(&self) -> Option<(&K, &V)>

Get the first key-value pair

Computes in O(1) time.

pub fn last(&self) -> Option<(&K, &V)>

Get the last key-value pair

Computes in O(1) time.

pub fn par_keys(&self) -> ParKeys<'_, K, V>

Return a parallel iterator over the keys of the map.

While parallel iterators can process items in any order, their relative order in the map is still preserved for operations like reduce and collect.

pub fn par_values(&self) -> ParValues<'_, K, V>

Return a parallel iterator over the values of the map.

While parallel iterators can process items in any order, their relative order in the map is still preserved for operations like reduce and collect.

pub fn par_eq<V2, S2>(&self, other: &IndexMap<K, V2, S2>) -> bool

where V: PartialEq<V2>, V2: Sync, S2: BuildHasher + Sync,

Returns true if self contains all of the same key-value pairs as other, regardless of each map’s indexed order, determined in parallel.

Trait Implementations

impl<N: Clone + Network> Clone for PuzzleSolutions<N>

fn clone(&self) -> PuzzleSolutions<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Network> Debug for PuzzleSolutions<N>

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

Prints the solutions as a JSON-string.

impl<N: Network> Deref for PuzzleSolutions<N>

type Target = IndexMap<SolutionID<N>, Solution<N>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de, N: Network> Deserialize<'de> for PuzzleSolutions<N>

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

Deserializes the solutions from a JSON-string or buffer.

impl<N: Network> Display for PuzzleSolutions<N>

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

Displays the solutions as a JSON-string.

impl<N: Network> FromBytes for PuzzleSolutions<N>

fn read_le<R: Read>(reader: R) -> IoResult<Self>

Reads the solutions from the buffer.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

Returns Self from a byte array in little-endian order.

impl<N: Network> FromStr for PuzzleSolutions<N>

fn from_str(solutions: &str) -> Result<Self, Self::Err>

Initializes the solutions from a JSON-string.

type Err = Error

The associated error which can be returned from parsing.

impl<N: PartialEq + Network> PartialEq for PuzzleSolutions<N>

fn eq(&self, other: &PuzzleSolutions<N>) -> 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<N: Network> Serialize for PuzzleSolutions<N>

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

Serializes the solutions to a JSON-string or buffer.

impl<N: Network> ToBytes for PuzzleSolutions<N>

fn write_le<W: Write>(&self, writer: W) -> IoResult<()>

Writes the solutions to the buffer.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>

where Self: Sized,

Returns self as a byte array in little-endian order.

impl<N: Eq + Network> Eq for PuzzleSolutions<N>

impl<N: Network> StructuralPartialEq for PuzzleSolutions<N>