Struct WildcardState 

pub struct WildcardState {
    child_writes: u16,
    child_reads: u16,
    max_foreign_access: WildcardAccessLevel,
    exposed_as: WildcardAccessLevel,
}

State per location per node keeping track of where relative to this node exposed nodes are and what access permissions they have.

Designed to be completely determined by its parent, siblings and direct children’s max_local_access/max_foreign_access.

Fields

child_writes: u16

How many of this node’s direct children have max_local_access()==Write.

child_reads: u16

How many of this node’s direct children have max_local_access()>=Read.

max_foreign_access: WildcardAccessLevel

The maximum access level that could happen from an exposed node that is foreign to this node.

This is calculated as the max() of the parent’s max_foreign_access, exposed_as and the siblings’ max_local_access().

exposed_as: WildcardAccessLevel

At what access level this node itself is exposed.

Implementations

impl WildcardState

fn max_local_access(&self) -> WildcardAccessLevel

The maximum access level that could happen from an exposed node that is local to this node.

pub fn access_relatedness( &self, kind: AccessKind, ) -> Option<WildcardAccessRelatedness>

From where relative to the node with this wildcard info a read or write access could happen.

fn read_access_relatedness(&self) -> Option<WildcardAccessRelatedness>

From where relative to the node with this wildcard info a read access could happen.

fn write_access_relatedness(&self) -> Option<WildcardAccessRelatedness>

From where relative to the node with this wildcard info a write access could happen.

pub fn for_new_child(&self) -> Self

Gets the access tracking information for a new child node of a parent with this wildcard info. The new node doesn’t have any child reads/writes, but calculates max_foreign_access from its parent.

fn push_relevant_children( stack: &mut Vec<(UniIndex, WildcardAccessLevel)>, new_foreign_access: WildcardAccessLevel, old_foreign_access: WildcardAccessLevel, child_reads: u16, child_writes: u16, children: impl Iterator<Item = UniIndex>, wildcard_accesses: &UniValMap<WildcardState>, )

Pushes the nodes of children onto the stack who’s max_foreign_access needs to be updated.

• children: A list of nodes with the same parent. children doesn’t necessarily have to contain all children of parent, but can just be a subset.

• child_reads, child_writes: How many of children have max_local_access() of at least read/write

• new_foreign_access, old_foreign_access: The max possible access level that is foreign to all children (i.e., it is not local to any of them). This can be calculated as the max of the parent’s exposed_as(), max_foreign_access and of all max_local_access() of any nodes with the same parent that are not listed in children.

  This access level changed from old to new, which is why we need to update children.

pub fn update_exposure( id: UniIndex, new_exposed_as: WildcardAccessLevel, nodes: &UniValMap<Node>, wildcard_accesses: &mut UniValMap<WildcardState>, )

Update the tracking information of a tree, to reflect that the node specified by id is now exposed with new_exposed_as.

Propagates the Willard access information over the tree. This needs to be called every time the access level of an exposed node changes, to keep the state in sync with the rest of the tree.

Trait Implementations

impl Clone for WildcardState

fn clone(&self) -> WildcardState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WildcardState

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

Formats the value using the given formatter.

impl Default for WildcardState

fn default() -> WildcardState

Returns the “default value” for a type.

impl PartialEq for WildcardState

fn eq(&self, other: &WildcardState) -> 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 Eq for WildcardState

impl StructuralPartialEq for WildcardState

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 6 bytes