Struct AreaOfInterest 

pub struct AreaOfInterest<const MCL: usize, const MCC: usize, const MPL: usize, S> { /* private fields */ }

An AreaOfInterest is an Area together with a maximum number of entries it may include, and a maximum sum of total payload_lengths for the included entries.

A max_count of u64::MAX indicates that there is no limit on the number of entries. A max_size of u64::MAX indicates that there is no limit on the total payload_lengths of the entries.

use willow_data_model::prelude::*;

let aoi = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
    5,
    400,
);

assert_eq!(aoi.area(), &Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)));
assert_eq!(aoi.max_count(), 5);
assert_eq!(aoi.max_size(), 400);

Specification

Implementations

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> AreaOfInterest<MCL, MCC, MPL, S>

pub fn new(area: Area<MCL, MCC, MPL, S>, max_count: u64, max_size: u64) -> Self

Creates a new AreaOfInterest from its constituent Area, max_count, and max_size.

A max_count of u64::MAX indicates that there is no limit on the number of entries. A max_size of u64::MAX indicates that there is no limit on the total payload_lengths of the entries.

use willow_data_model::prelude::*;

let aoi = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
    5,
    400,
);

assert_eq!(
    aoi.area(),
    &Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
);
assert_eq!(aoi.max_count(), 5);
assert_eq!(aoi.max_size(), 400);

pub fn area(&self) -> &Area<MCL, MCC, MPL, S>

Returns a reference to the inner Area.

use willow_data_model::prelude::*;

let aoi = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
    5,
    400,
);
assert_eq!(aoi.area(), &Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)));

Definition.

pub fn max_count(&self) -> u64

Returns the max_count of entries.

A max_count of u64::MAX indicates that there is no limit on the number of entries in this area of interest.

use willow_data_model::prelude::*;

let aoi = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
    5,
    400,
);
assert_eq!(aoi.max_count(), 5);

Definition.

pub fn max_size(&self) -> u64

Returns the max_count of entries.

A max_size of u64::MAX indicates that there is no limit on the total payload_lengths of the entries in this area of interest.

use willow_data_model::prelude::*;

let aoi = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
    5,
    400,
);
assert_eq!(aoi.max_size(), 400);

Definition.

pub fn set_area(&mut self, new_area: Area<MCL, MCC, MPL, S>)

Sets the inner area.

pub fn set_max_count(&mut self, new_max_count: u64)

Sets the max_count.

A max_count of u64::MAX indicates that there is no limit on the number of entries in this area of interest.

pub fn set_max_size(&mut self, new_max_size: u64)

Sets the max_size.

A max_size of u64::MAX indicates that there is no limit on the total payload_lengths of the entries in this area of interest.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

pub fn is_empty(&self) -> bool

Returns true iff this area of interest cannot possibly contain any entries.

use willow_data_model::prelude::*;

assert!(
    !AreaOfInterest::new(
        Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
        5,
        400,
    ).is_empty(),
);
assert!(
    !AreaOfInterest::new(
        Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
        5,
        0, // Could still possibly contain entries with a payload_length of zero.
    ).is_empty(),
);

assert!(
    AreaOfInterest::new(
        Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
        0,
        400,
    ).is_empty(),
);
assert!(
    AreaOfInterest::new(
        Area::<2, 2, 2, u8>::wdm_empty(),
        5,
        400,
    ).is_empty(),
);

pub fn intersection(&self, other: &Self) -> Self

Returns the intersection of self and other.

use willow_data_model::prelude::*;

let aoi1 = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), ..Timestamp::from(17)),
    5,
    400,
);
let aoi2 = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), Timestamp::from(14)..),
    12,
    32,
);

assert_eq!(
    aoi1.intersection(&aoi2),
    AreaOfInterest::new(
        Area::<2, 2, 2, u8>::new(
            None,
            Path::new(),
            Timestamp::from(14)..Timestamp::from(17),
        ),
        5,
        32,
    ),
);

Trait Implementations

impl<'arbitrary, const MCL: usize, const MCC: usize, const MPL: usize, S: Arbitrary<'arbitrary>> Arbitrary<'arbitrary> for AreaOfInterest<MCL, MCC, MPL, S>

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S: Clone> Clone for AreaOfInterest<MCL, MCC, MPL, S>

fn clone(&self) -> AreaOfInterest<MCL, MCC, MPL, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S: Debug> Debug for AreaOfInterest<MCL, MCC, MPL, S>

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

Formats the value using the given formatter.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> GreatestElement for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn greatest() -> Self

Returns the unique greatest element.

fn is_greatest(&self) -> bool

Returns true if and only if self is the greatest element.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> Hash for AreaOfInterest<MCL, MCC, MPL, S>

where S: Hash + Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

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<const MCL: usize, const MCC: usize, const MPL: usize, S> LeastElement for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn least() -> Self

Returns the unique least element.

fn is_least(&self) -> bool

Returns true if and only if self is the least element.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> LowerSemilattice for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn greatest_lower_bound(&self, other: &Self) -> Self

Returns the greatest lower bound of self and other, i.e., the unique greatest element in the type which is less than or equal to both self and other.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> PartialEq for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

An area is equal to another iff both are empty, or both have equal constituent values.

This implementation assumes that S is inhabited by more than one value.

fn eq(&self, other: &Self) -> 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<const MCL: usize, const MCC: usize, const MPL: usize, S> PartialOrd for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

An area is less than another iff is is empty but the other is not, or if its area is less than the other’s area and its max_count and max_size are not strictly greater than those of the other.

This implementation assumes that S is inhabited by more than one value.

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

An area is less than another iff it has a max_count of zero (and the other doesn’t), or if its area is less than the other’s area and its max_count and max_size are not strictly greater than those of the other.

This implementation assumes that S is inhabited by more than one value.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> UpperSemilattice for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn least_upper_bound(&self, other: &Self) -> Self

Returns the least upper bound of self and other, i.e., the unique least element in the type which is greater than or equal to both self and other.

impl<const MCL: usize, const MCC: usize, const MPL: usize, S> Eq for AreaOfInterest<MCL, MCC, MPL, S>

where S: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,