Struct syscalls::SysnoSet

pub struct SysnoSet { /* private fields */ }

A set of syscalls.

This provides constant-time lookup of syscalls within a bitset.

Examples

let syscalls = SysnoSet::new(&[Sysno::read, Sysno::write, Sysno::openat, Sysno::close]);
assert!(syscalls.contains(Sysno::read));
assert!(syscalls.contains(Sysno::close));

Most operations can be done at compile-time as well.

const SYSCALLS: SysnoSet =
    SysnoSet::new(&[Sysno::read, Sysno::write, Sysno::close])
        .union(&SysnoSet::new(&[Sysno::openat]));
const _: () = assert!(SYSCALLS.contains(Sysno::read));
const _: () = assert!(SYSCALLS.contains(Sysno::openat));

Implementations

impl SysnoSet

pub const fn new(syscalls: &[Sysno]) -> Self

Initialize the syscall set with the given slice of syscalls.

Since this is a const fn, this can be used at compile-time.

pub const fn empty() -> Self

Creates an empty set of syscalls.

pub const fn all() -> Self

Creates a set containing all valid syscalls.

pub const fn contains(&self, sysno: Sysno) -> bool

Returns true if the set contains the given syscall.

pub fn is_empty(&self) -> bool

Returns true if the set is empty. Although this is an O(1) operation (because the total number of possible syscalls is always constant), it must go through the whole bit set to count the number of bits. Thus, this may have a large, constant overhead.

pub fn clear(&mut self)

Clears the set, removing all syscalls.

pub fn count(&self) -> usize

Returns the number of syscalls in the set. Although this is an O(1) operation (because the total number of syscalls is always constant), it must go through the whole bit set to count the number of bits. Thus, this may have a large, constant overhead.

pub fn insert(&mut self, sysno: Sysno) -> bool

Inserts the given syscall into the set. Returns true if the syscall was not already in the set.

pub fn remove(&mut self, sysno: Sysno) -> bool

Removes the given syscall from the set. Returns true if the syscall was in the set.

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

Does a set union with this set and another.

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

Does a set intersection with this set and another.

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

Calculates the difference with this set and another. That is, the resulting set only includes the syscalls that are in self but not in other.

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

Calculates the symmetric difference with this set and another. That is, the resulting set only includes the syscalls that are in self or in other, but not in both.

pub fn iter(&self) -> SysnoSetIter<'_>

Returns an iterator that iterates over the syscalls contained in the set.

Trait Implementations

impl BitOr for SysnoSet

type Output = SysnoSet

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<&SysnoSet> for SysnoSet

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl BitOrAssign<Sysno> for SysnoSet

fn bitor_assign(&mut self, sysno: Sysno)

Performs the |= operation.

impl BitOrAssign for SysnoSet

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for SysnoSet

fn clone(&self) -> SysnoSet

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SysnoSet

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

Formats the value using the given formatter.

impl Default for SysnoSet

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SysnoSet

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<Sysno> for SysnoSet

fn extend<T: IntoIterator<Item = Sysno>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<Sysno> for SysnoSet

fn from_iter<I: IntoIterator<Item = Sysno>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a SysnoSet

type Item = Sysno

The type of the elements being iterated over.

type IntoIter = SysnoSetIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for SysnoSet

fn eq(&self, other: &SysnoSet) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SysnoSet

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SysnoSet

impl StructuralPartialEq for SysnoSet