Enum hwlocality::object::depth::Depth

pub enum Depth {
    Normal(NormalDepth),
    NUMANode,
    Bridge,
    PCIDevice,
    OSDevice,
    Misc,
    MemCache,
}

Valid object/type depth values

See the module-level documentation for context.

Variants

Normal(NormalDepth)

Depth of a normal object (not Memory, I/O or Misc)

NUMANode

Virtual depth for ObjectType::NUMANode

Bridge

Virtual depth for ObjectType::Bridge

PCIDevice

Virtual depth for ObjectType::PCIDevice

OSDevice

Virtual depth for ObjectType::OSDevice

Misc

Virtual depth for ObjectType::Misc

MemCache

Available on crate feature hwloc-2_1_0 only.

Virtual depth for ObjectType::MemCache

Implementations

impl Depth

pub fn expect_normal(self) -> NormalDepth

Assert that this should be a normal object depth, panicking if it turns out not to be the case.

pub const VIRTUAL_DEPTHS: &'static [Self] = _

List of virtual depths

pub const MEMORY_DEPTHS: &'static [Self] = _

List of memory object virtual depths

pub const IO_DEPTHS: &'static [Self] = _

List of I/O object virtual depths

Trait Implementations

impl Arbitrary for Depth

Available on crate feature proptest only.

type Parameters = <PositiveInt as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = TupleUnion<((u32, Arc<Map<<PositiveInt as Arbitrary>::Strategy, fn(_: PositiveInt) -> Depth>>), (u32, Arc<Select<Depth>>))>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for Depth

fn clone(&self) -> Depth

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Depth

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

Formats the value using the given formatter.

impl Default for Depth

fn default() -> Self

Returns the “default value” for a type.

impl Display for Depth

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

Formats the value using the given formatter.

impl From<PositiveInt> for Depth

fn from(value: NormalDepth) -> Self

Converts to this type from the input type.

impl Hash for Depth

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 PartialEq<Depth> for NormalDepth

fn eq(&self, other: &Depth) -> 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 PartialEq<Depth> for usize

fn eq(&self, other: &Depth) -> 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 PartialEq<PositiveInt> for Depth

fn eq(&self, other: &NormalDepth) -> 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 PartialEq<usize> for Depth

fn eq(&self, other: &usize) -> 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 PartialEq for Depth

fn eq(&self, other: &Depth) -> 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 TryFrom<Depth> for NormalDepth

type Error = Depth

The type returned in the event of a conversion error.

fn try_from(value: Depth) -> Result<Self, Depth>

Performs the conversion.

impl TryFrom<Depth> for usize

type Error = Depth

The type returned in the event of a conversion error.

fn try_from(value: Depth) -> Result<Self, Depth>

Performs the conversion.

impl TryFrom<usize> for Depth

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<Self, TryFromIntError>

Performs the conversion.

impl Copy for Depth

impl Eq for Depth

impl StructuralPartialEq for Depth