Struct GenericRange

pub struct GenericRange<T> {
    start: Option<T>,
    end: Option<T>,
}

A half-open time range.

The range contains values that value >= start and val < end.

The range is empty iff start == end == "the default value of T"

Fields

start: Option<T>

end: Option<T>

Implementations

impl<T> GenericRange<T>

where T: Copy + PartialOrd + Default,

pub fn and(&self, other: &GenericRange<T>) -> GenericRange<T>

Computes the AND’ed range with other.

pub fn or(&self, other: &GenericRange<T>) -> GenericRange<T>

Compute the OR’ed range of two ranges. Notice: this method does not compute the exact OR’ed operation for simplicity. For example, [1, 2) or’ed with [4, 5) will produce [1, 5) instead of [1, 2) ∪ [4, 5)

pub fn intersects(&self, target: &GenericRange<T>) -> bool

Checks if current range intersect with target.

pub fn empty() -> GenericRange<T>

Create an empty range.

fn from_optional(start: Option<T>, end: Option<T>) -> GenericRange<T>

Create GenericRange from optional start and end. If the present value of start >= the present value of end, it will return an empty range with the default value of T.

impl<T> GenericRange<T>

pub fn new<U: PartialOrd + Into<T>>(start: U, end: U) -> Option<GenericRange<T>>

Creates a new range that contains values in [start, end).

Returns None if start > end.

pub fn min_to_max() -> GenericRange<T>

Return a range containing all possible values.

pub fn start(&self) -> &Option<T>

Returns the lower bound of the range (inclusive).

pub fn end(&self) -> &Option<T>

Returns the upper bound of the range (exclusive).

pub fn contains<U: PartialOrd<T>>(&self, target: &U) -> bool

Returns true if timestamp is contained in the range.

impl<T: PartialOrd> GenericRange<T>

pub fn is_empty(&self) -> bool

Returns true if the range contains no timestamps.

impl GenericRange<Timestamp>

pub fn new_inclusive(start: Option<Timestamp>, end: Option<Timestamp>) -> Self

Create a TimestampRange with optional inclusive end timestamp. If end timestamp is present and is less than start timestamp, this method will return an empty range.

Caveat

If the given end timestamp’s value is i64::MAX, which will result into overflow when added by 1(the end is inclusive), this method does not try to convert the time unit of end timestamp, instead it just return [start, INF). This exaggerates the range but does not affect correctness.

pub fn with_unit(start: i64, end: i64, unit: TimeUnit) -> Option<Self>

Shortcut method to create a timestamp range with given start/end value and time unit. Returns empty iff start > end.

pub fn single(ts: Timestamp) -> Self

Create a range that containing only given ts.

Notice:

Left-close right-open range cannot properly represent range with a single value. For simplicity, this implementation returns an approximate range [ts, ts+1) instead.

pub fn from_start(start: Timestamp) -> Self

Create a range [start, INF).

Notice

Left-close right-open range cannot properly represent range with exclusive start like: (start, ...). You may resort to [start-1, ...) instead.

pub fn until_end(end: Timestamp, inclusive: bool) -> Self

Create a range [-INF, end).

Notice

Left-close right-open range cannot properly represent range with inclusive end like: [..., END]. If inclusive is true, this method returns [-INF, end+1) instead.

Trait Implementations

impl<T: Clone> Clone for GenericRange<T>

fn clone(&self) -> GenericRange<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for GenericRange<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for GenericRange<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Hash> Hash for GenericRange<T>

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<T: PartialEq> PartialEq for GenericRange<T>

fn eq(&self, other: &GenericRange<T>) -> 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<T> Serialize for GenericRange<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy> Copy for GenericRange<T>

impl<T: Eq> Eq for GenericRange<T>

impl<T> StructuralPartialEq for GenericRange<T>