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(), TimeRange::new_closed(0.into(), 17.into())),
    NonZeroU64::new(5).unwrap(),
    400,
);

assert_eq!(aoi.area(), &Area::<2, 2, 2, u8>::new(None, Path::new(), TimeRange::new_closed(0.into(), 17.into())));
assert_eq!(aoi.max_count(), NonZeroU64::new(5).unwrap());
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: NonZeroU64, 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(), TimeRange::new_closed(0.into(), 17.into())),
    NonZeroU64::new(5).unwrap(),
    400,
);

assert_eq!(
    aoi.area(),
    &Area::<2, 2, 2, u8>::new(None, Path::new(), TimeRange::new_closed(0.into(), 17.into())),
);
assert_eq!(aoi.max_count(), NonZeroU64::new(5).unwrap());
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(), TimeRange::new_closed(0.into(), 17.into())),
    NonZeroU64::new(5).unwrap(),
    400,
);
assert_eq!(aoi.area(), &Area::<2, 2, 2, u8>::new(None, Path::new(), TimeRange::new_closed(0.into(), 17.into())));

Definition.

pub fn max_count(&self) -> NonZeroU64

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(), TimeRange::new_closed(0.into(), 17.into())),
    NonZeroU64::new(5).unwrap(),
    400,
);
assert_eq!(aoi.max_count(), NonZeroU64::new(5).unwrap());

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(), TimeRange::new_closed(0.into(), 17.into())),
    NonZeroU64::new(5).unwrap(),
    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: NonZeroU64)

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: PartialEq + Clone,

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

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(), TimeRange::new_closed(0.into(), 17.into())),
    NonZeroU64::new(5).unwrap(),
    400,
);
let aoi2 = AreaOfInterest::new(
    Area::<2, 2, 2, u8>::new(None, Path::new(), TimeRange::new_open(14.into())),
    NonZeroU64::new(12).unwrap(),
    32,
);

assert_eq!(
    aoi1.intersection(&aoi2),
    Ok(AreaOfInterest::new(
        Area::<2, 2, 2, u8>::new(
            None,
            Path::new(),
            TimeRange::new_closed(14.into(), 17.into()),
        ),
        NonZeroU64::new(5).unwrap(),
        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> Hash for AreaOfInterest<MCL, MCC, MPL, S>

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

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

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