Struct brane_exe::pc::ProgramCounter

pub struct ProgramCounter {
    pub func_id: FunctionId,
    pub edge_idx: usize,
}

Used to keep track of the current executing edge in a workflow.

Fields

func_id: FunctionId

The function ID of the function currently being executed.

edge_idx: usize

The edge that we’re executing in that function.

Implementations

impl ProgramCounter

pub fn new( func_id: impl Into<FunctionId>, edge_idx: impl AsPrimitive<usize>, ) -> Self

Creates a new program counter from the given FunctionId and the given index in that function.

Arguments

• func_id: A FunctionId-like to use as current function.
• edge_idx: A usize-like to use as edge index within the given func_id.

Returns

A new ProgramCounter instance.

pub const fn start() -> Self

Creates a new program counter that points to the start of the <main>-function.

Returns

A new ProgramCounter instance.

pub fn start_of(func_id: impl Into<FunctionId>) -> Self

Creates a new program counter that points to the start of the given function.

Arguments

• func_id: A FunctionId-like to use as current function.

Returns

A new ProgramCounter instance.

pub fn jump(&self, next: impl AsPrimitive<usize>) -> Self

Returns a ProgramCounter that points to the given edge within the same function.

This function returns a new instance. To update an existing one, use ProgramCounter::jump_mut().

Arguments

• next: The edge index of the new edge within this function.

Returns

A new ProgramCounter that points to the same function as self and the given next.

pub fn jump_mut(&mut self, next: impl AsPrimitive<usize>) -> &mut Self

Updates this program counter with a new edge index.

This function mutates self. To instead receive a new instance, use ProgramCounter::jump

Arguments

• next: The edge index of the new edge within this function.

Returns

Self for chaining.

pub fn call(func: impl Into<FunctionId>) -> Self

Returns a ProgramCounter that points to the start of another function.

This function returns a new instance. To update an existing one, use ProgramCounter::call_mut.

Arguments

• func: The identifier of the function to point to.

Returns

A new ProgramCounter that points to the given func and the first edge within (i.e., edge 0).

pub fn call_mut(&mut self, func: impl Into<FunctionId>) -> &mut Self

Updates this program counter such that it points to the start of the given function.

This function mutates self. To instead receive a new instance, use ProgramCounter::call.

Arguments

• func: The identifier of the function to point to.

Returns

Self for chaining.

pub fn resolved(&self, symtable: &SymTable) -> ResolvedProgramCounter

Returns a formatter that shows the resolved name of the function.

Arguments

• symtable: A workflow SymTable that is used to resolve the function identifiers to names.

Returns

A ResolvedProgramCounter that does the actual formatting as it implements Display.

pub fn is_main(&self) -> bool

Returns whether this ProgramCounter points to somewhere in the <main> function.

Returns

True if self.func_id.is_main() is true, or else false.

Trait Implementations

impl Add<usize> for ProgramCounter

fn add(self, rhs: usize) -> Self::Output

Adds a number of edges to this ProgramCounter.

Arguments

• rhs: The number of edges to move forward.

Returns

A new ProgramCounter that points to the same function and the same edge index, except the latter is added to rhs.

type Output = ProgramCounter

The resulting type after applying the + operator.

impl AddAssign<usize> for ProgramCounter

fn add_assign(&mut self, rhs: usize)

Adds a number of edges to this ProgramCounter, but mutably instead of returning a new object.

Arguments

• rhs: The number of edges to move forward.

impl Clone for ProgramCounter

fn clone(&self) -> ProgramCounter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProgramCounter

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

Formats the value using the given formatter.

impl Default for ProgramCounter

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ProgramCounter

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ProgramCounter

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

Formats the value using the given formatter.

impl From<&ProgramCounter> for ProgramCounter

fn from(value: &Self) -> Self

Converts to this type from the input type.

impl From<&mut ProgramCounter> for ProgramCounter

fn from(value: &mut Self) -> Self

Converts to this type from the input type.

impl FromStr for ProgramCounter

type Err = ProgramCounterParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for ProgramCounter

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 for ProgramCounter

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

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ProgramCounter

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ProgramCounter

impl Eq for ProgramCounter

impl StructuralPartialEq for ProgramCounter