Struct PROG_STREAM_OPEN_SUPPORTED 

pub struct PROG_STREAM_OPEN_SUPPORTED {
    __private_field: (),
}

prog_stream_open() works, so BPF streams can be polled.

Fields

__private_field: ()

Methods from Deref<Target = bool>

pub fn then_some<T>(self, t: T) -> Option<T>

Returns Some(t) if the bool is true, or None otherwise.

Arguments passed to then_some are eagerly evaluated; if you are passing the result of a function call, it is recommended to use then, which is lazily evaluated.

Examples

assert_eq!(false.then_some(0), None);
assert_eq!(true.then_some(0), Some(0));

let mut a = 0;
let mut function_with_side_effects = || { a += 1; };

true.then_some(function_with_side_effects());
false.then_some(function_with_side_effects());

// `a` is incremented twice because the value passed to `then_some` is
// evaluated eagerly.
assert_eq!(a, 2);

pub fn then<T, F>(self, f: F) -> Option<T>

where F: FnOnce() -> T,

Returns Some(f()) if the bool is true, or None otherwise.

Examples

assert_eq!(false.then(|| 0), None);
assert_eq!(true.then(|| 0), Some(0));

let mut a = 0;

true.then(|| { a += 1; });
false.then(|| { a += 1; });

// `a` is incremented once because the closure is evaluated lazily by
// `then`.
assert_eq!(a, 1);

pub fn ok_or<E>(self, err: E) -> Result<(), E>

Returns Ok(()) if the bool is true, or Err(err) otherwise.

Arguments passed to ok_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use ok_or_else, which is lazily evaluated.

Examples

assert_eq!(false.ok_or(0), Err(0));
assert_eq!(true.ok_or(0), Ok(()));

let mut a = 0;
let mut function_with_side_effects = || { a += 1; };

assert!(true.ok_or(function_with_side_effects()).is_ok());
assert!(false.ok_or(function_with_side_effects()).is_err());

// `a` is incremented twice because the value passed to `ok_or` is
// evaluated eagerly.
assert_eq!(a, 2);

pub fn ok_or_else<E, F>(self, f: F) -> Result<(), E>

where F: FnOnce() -> E,

Returns Ok(()) if the bool is true, or Err(f()) otherwise.

Examples

assert_eq!(false.ok_or_else(|| 0), Err(0));
assert_eq!(true.ok_or_else(|| 0), Ok(()));

let mut a = 0;

assert!(true.ok_or_else(|| { a += 1; }).is_ok());
assert!(false.ok_or_else(|| { a += 1; }).is_err());

// `a` is incremented once because the closure is evaluated lazily by
// `ok_or_else`.
assert_eq!(a, 1);

pub unsafe fn unchecked_disjoint_bitor(self, rhs: bool) -> bool

🔬This is a nightly-only experimental API. (disjoint_bitor)

Disjoint, bitwise or. Computes self | rhs, assuming at most one, true value.

Practically, this requires that self | rhs and self ^ rhs both yield the same result, allowing for any of the two to be emitted in codegen – depending on whichever is cheapest.

Examples

#![feature(disjoint_bitor)]

assert_eq!(
    // SAFETY: Only one, true value is passed.
    unsafe { false.unchecked_disjoint_bitor(true) },
    true,
);

assert_eq!(
    // SAFETY: No true values are passed.
    unsafe { false.unchecked_disjoint_bitor(false) },
    false,
);

Safety

This results in undefined behaviour if both self and rhs are true.

Trait Implementations

impl Deref for PROG_STREAM_OPEN_SUPPORTED

type Target = bool

The resulting type after dereferencing.

fn deref(&self) -> &bool

Dereferences the value.

impl LazyStatic for PROG_STREAM_OPEN_SUPPORTED