Enum Bound 

pub enum Bound<T> {
    Included(T),
    Excluded(T),
    Unbounded,
}

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

An endpoint of a range of keys.

Examples

Bounds are range endpoints:

use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((..100).start_bound(), Unbounded);
assert_eq!((1..12).start_bound(), Included(&1));
assert_eq!((1..12).end_bound(), Excluded(&12));

Using a tuple of Bounds as an argument to BTreeMap::range. Note that in most cases, it’s better to use range syntax (1..5) instead.

use std::collections::BTreeMap;
use std::ops::Bound::{Excluded, Included, Unbounded};

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");

for (key, value) in map.range((Excluded(3), Included(8))) {
    println!("{key}: {value}");
}

assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());

Variants

Included(T)

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

An inclusive bound.

Excluded(T)

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

An exclusive bound.

Unbounded

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

An infinite endpoint. Indicates that there is no bound in this direction.

Implementations

impl<T> Bound<T>

pub fn as_ref(&self) -> Bound<&T>

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Converts from &Bound<T> to Bound<&T>.

pub const fn as_mut(&mut self) -> Bound<&mut T>

🔬This is a nightly-only experimental API. (bound_as_ref #80996)

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Converts from &mut Bound<T> to Bound<&mut T>.

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Bound<U>

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Maps a Bound<T> to a Bound<U> by applying a function to the contained value (including both Included and Excluded), returning a Bound of the same kind.

Examples

use std::ops::Bound::*;

let bound_string = Included("Hello, World!");

assert_eq!(bound_string.map(|s| s.len()), Included(13));

use std::ops::Bound;
use Bound::*;

let unbounded_string: Bound<String> = Unbounded;

assert_eq!(unbounded_string.map(|s| s.len()), Unbounded);

impl<T: Copy> Bound<&T>

pub const fn copied(self) -> Bound<T>

🔬This is a nightly-only experimental API. (bound_copied #145966)

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Map a Bound<&T> to a Bound<T> by copying the contents of the bound.

Examples

#![feature(bound_copied)]

use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((1..12).start_bound(), Included(&1));
assert_eq!((1..12).start_bound().copied(), Included(1));

impl<T: Clone> Bound<&T>

pub fn cloned(self) -> Bound<T>

where T: Clone,

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Map a Bound<&T> to a Bound<T> by cloning the contents of the bound.

Examples

use std::ops::Bound::*;
use std::ops::RangeBounds;

let a1 = String::from("a");
let (a2, a3, a4) = (a1.clone(), a1.clone(), a1.clone());

assert_eq!(Included(&a1), (a2..).start_bound());
assert_eq!(Included(a3), (a4..).start_bound().cloned());

Trait Implementations

impl<T: Clone> Clone for Bound<T>

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

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Returns a duplicate of the value.

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

where Self:,

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Performs copy-assignment from source.

impl<T: Copy> Copy for Bound<T>

impl<T: Debug> Debug for Bound<T>

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

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Formats the value using the given formatter.

impl<T: Eq> Eq for Bound<T>

impl<T: Hash> Hash for Bound<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Feeds this value into the given Hasher.

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H)

where Self: Sized,

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Bound<T>

fn eq(&self, other: &Bound<T>) -> bool

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Equality operator ==.

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

This item is validated for IEC 61508 (SIL 2) and ISO 26262 (ASIL B).

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for Bound<T>