Struct Workflow

pub struct Workflow {
    pub name: String,
    pub version: String,
    pub tasks: HashMap<String, Task>,
}

Fields

name: String

version: String

tasks: HashMap<String, Task>

Implementations

impl Workflow

pub fn get_dependencies(&self, task_name: &str) -> Option<Vec<String>>

Finds the list of dependencies that the given task depends on.

Arguments

• task_name - A string slice that holds the name of the task
• workflow_index - A integer that holds the index of the workflow where the given task is stored

Returns

• Option<Vec<String>> - An option containing a vector of dependencies if the task is found, or None if the task have no dependency

pub fn get_flow(&self) -> Vec<String>

Performs topological sort in the workflow graph. This method is invoked by the parse_module.

Arguments

• workflow_index - An integer that holds the index of the workflow for which topological sort is to be performed

Returns

• Vec<String> - A vector containing the list of task names in the order of the topological sort

impl Workflow

pub fn from_value<'v>(x: Value<'v>) -> Option<&'v Self>

Downcast a value to self type.

Trait Implementations

impl AllocFrozenValue for Workflow

fn alloc_frozen_value(self, heap: &FrozenHeap) -> FrozenValue

Allocate a value in the frozen heap and return a reference to the allocated value.

impl<'v> AllocValue<'v> for Workflow

fn alloc_value(self, heap: &'v Heap) -> Value<'v>

Allocate the value on a heap and return a reference to the allocated value.

impl Allocative for Workflow

fn visit<'allocative_a, 'allocative_b: 'allocative_a>( &self, visitor: &'allocative_a mut Visitor<'allocative_b>, )

impl Clone for Workflow

fn clone(&self) -> Workflow

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Workflow

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Workflow

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Workflow

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

Formats the value using the given formatter.

impl PartialEq for Workflow

fn eq(&self, other: &Workflow) -> 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<'pst> ProvidesStaticType<'pst> for Workflow

type StaticType = Workflow

Same type as Self but with lifetimes dropped to 'static.

impl Serialize for Workflow

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'v> StarlarkTypeRepr for &'v Workflow

fn starlark_type_repr() -> Ty

The representation of a type that a user would use verbatim in starlark type annotations

impl<'v> StarlarkValue<'v> for Workflow

const TYPE: &'static str = "Workflow"

Return a string describing the type of self, as returned by the type() function.

type Canonical = Workflow

Two implementations of StarlarkValue are considered to have the same type, if Canonical field points to the same type.

fn get_type_value_static() -> FrozenStringValue

Like TYPE, but returns a reusable FrozenStringValue pointer to it. This function deliberately doesn’t take a heap, as it would not be performant to allocate a new value each time.

fn attr_ty(_attr: &str) -> Option<Ty>

Attribute type, for the typechecker.

fn get_type_starlark_repr() -> Ty

Return a string that is the representation of a type that a user would use in type annotations. This often will be the same as Self::TYPE, but in some instances it might be slightly different than what is returned by TYPE.

fn matches_type(&self, ty: &str) -> bool

Is this value a match for a named type. Usually returns true for values matching get_type, but might also work for subtypes it implements.

fn get_methods() -> Option<&'static Methods>

where Self: Sized,

Get the members associated with this type, accessible via this_type.x. These members will have dir/getattr/hasattr properly implemented, so it is the preferred way to go if possible. See MethodsStatic for an example of how to define this method.

fn documentation(&self) -> Option<DocItem>

where Self: Sized,

Return structured documentation for self, if available.

fn typechecker_ty(&self) -> Option<Ty>

Type of this instance for typechecker. Note this can be more precise than generic type.

fn collect_repr(&self, collector: &mut String)

Return a string representation of self, as returned by the repr() function. Defaults to the Display instance - which should be fine for nearly all types. In many cases the repr() representation will also be a Starlark expression for creating the value.

fn collect_repr_cycle(&self, collector: &mut String)

Invoked to print repr when a cycle is the object stack is detected.

fn name_for_call_stack(&self, me: Value<'v>) -> String

String used when printing call stack. repr(self) by default.

fn to_bool(&self) -> bool

Convert self to a boolean, as returned by the bool() function. The default implementation returns true.

fn write_hash(&self, hasher: &mut StarlarkHasher) -> Result<(), Error>

Return a hash data for self to be used when self is placed as a key in a Dict. Return an Err if there is no hash for this value (e.g. list). Must be stable between frozen and non-frozen values.

fn equals(&self, _other: Value<'v>) -> Result<bool, Error>

Compare self with other for equality. Should only return an error on excessive recursion.

fn compare(&self, other: Value<'v>) -> Result<Ordering, Error>

Compare self with other. This method returns a result of type Ordering, or an Err if the two types differ.

fn invoke( &self, _me: Value<'v>, _args: &Arguments<'v, '_>, _eval: &mut Evaluator<'v, '_>, ) -> Result<Value<'v>, Error>

Directly invoke a function. The number of named and names arguments are guaranteed to be equal.

fn at(&self, index: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Return the result of a[index] if a is indexable.

fn at2( &self, _index0: Value<'v>, _index1: Value<'v>, _heap: &'v Heap, _private: Private, ) -> Result<Value<'v>, Error>

Return the result of a[index0, index1] if a is indexable by two parameters.

fn slice( &self, _start: Option<Value<'v>>, _stop: Option<Value<'v>>, _stride: Option<Value<'v>>, _heap: &'v Heap, ) -> Result<Value<'v>, Error>

Extract a slice of the underlying object if the object is indexable. The result will be object between start and stop (both of them are added length() if negative and then clamped between 0 and length()). stride indicates the direction.

fn iterate_collect(&self, _heap: &'v Heap) -> Result<Vec<Value<'v>>, Error>

Implement iteration over the value of this container by providing the values in a Vec.

unsafe fn iterate( &self, _me: Value<'v>, heap: &'v Heap, ) -> Result<Value<'v>, Error>

Returns an iterator over the value of this container if this value holds an iterable container.

unsafe fn iter_size_hint(&self, _index: usize) -> (usize, Option<usize>)

Returns the size hint for the iterator.

unsafe fn iter_next(&self, _index: usize, _heap: &'v Heap) -> Option<Value<'v>>

Yield the next value from the iterator.

unsafe fn iter_stop(&self)

Indicate that the iteration is finished.

fn length(&self) -> Result<i32, Error>

Returns the length of the value, if this value is a sequence.

fn get_attr(&self, _attribute: &str, _heap: &'v Heap) -> Option<Value<'v>>

Get an attribute for the current value as would be returned by dotted expression (i.e. a.attribute).

fn get_attr_hashed( &self, attribute: Hashed<&str>, heap: &'v Heap, ) -> Option<Value<'v>>

A version of get_attr which takes BorrowHashed<str> instead of &str, thus implementation may reuse the hash of the string if this is called repeatedly with the same string.

fn has_attr(&self, attribute: &str, heap: &'v Heap) -> bool

Return true if an attribute of name attribute exists for the current value.

fn dir_attr(&self) -> Vec<String>

Return a vector of string listing all attribute of the current value.

fn is_in(&self, other: Value<'v>) -> Result<bool, Error>

Tell whether other is in the current value, if it is a container.

fn plus(&self, _heap: &'v Heap) -> Result<Value<'v>, Error>

Apply the + unary operator to the current value.

fn minus(&self, _heap: &'v Heap) -> Result<Value<'v>, Error>

Apply the - unary operator to the current value.

fn radd( &self, _lhs: Value<'v>, _heap: &'v Heap, ) -> Option<Result<Value<'v>, Error>>

Add with the arguments the other way around. Should return None to fall through to normal add.

fn add( &self, _rhs: Value<'v>, _heap: &'v Heap, ) -> Option<Result<Value<'v>, Error>>

Add other to the current value. Pass both self and the Value form of self as original.

fn sub(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Subtract other from the current value.

fn rmul( &self, lhs: Value<'v>, heap: &'v Heap, ) -> Option<Result<Value<'v>, Error>>

Called on rhs of lhs * rhs when lhs.mul returns None.

fn mul( &self, _rhs: Value<'v>, _heap: &'v Heap, ) -> Option<Result<Value<'v>, Error>>

Multiply the current value with other.

fn div(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Divide the current value by other. Always results in a float value.

fn percent(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Apply the percent operator between the current value and other. Usually used on strings, as per the Starlark spec.

fn floor_div( &self, other: Value<'v>, _heap: &'v Heap, ) -> Result<Value<'v>, Error>

Floor division between the current value and other.

fn bit_and(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Bitwise & operator.

fn bit_or(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Bitwise | operator.

fn bit_xor(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>, Error>

Bitwise ^ operator.

fn bit_not(&self, _heap: &'v Heap) -> Result<Value<'v>, Error>

Bitwise ~ operator.

fn left_shift( &self, other: Value<'v>, _heap: &'v Heap, ) -> Result<Value<'v>, Error>

Bitwise << operator.

fn right_shift( &self, other: Value<'v>, _heap: &'v Heap, ) -> Result<Value<'v>, Error>

Bitwise >> operator.

fn bin_op_ty(_op: TypingBinOp, _rhs: &TyBasic) -> Option<Ty>

Typecheck this op rhs.

fn rbin_op_ty(_lhs: &TyBasic, _op: TypingBinOp) -> Option<Ty>

Typecheck lhs op this.

fn export_as( &self, _variable_name: &str, _eval: &mut Evaluator<'v, '_>, ) -> Result<(), Error>

Called when exporting a value under a specific name,

fn set_at(&self, _index: Value<'v>, _new_value: Value<'v>) -> Result<(), Error>

Set the value at index with the new value.

fn set_attr(&self, attribute: &str, _new_value: Value<'v>) -> Result<(), Error>

Set the attribute named attribute of the current value to value (e.g. a.attribute = value).

fn provide(&'v self, demand: &mut Demand<'_, 'v>)

Dynamically provide values based on type.

impl<'v> UnpackValue<'v> for &'v Workflow

fn expected() -> String

Description of values acceptable by unpack_value, e. g. list or str.

fn unpack_value(x: Value<'v>) -> Option<&'v Workflow>

Given a Value, try and unpack it into the given type, which may involve some element of conversion.

fn unpack_value_err(value: Value<'v>) -> Result<Self, Error>

Unpack a value, but return error instead of None if unpacking fails.

fn unpack_param(value: Value<'v>) -> Result<Self, Error>

Unpack value, but instead of None return error about incorrect argument type.

fn unpack_named_param(value: Value<'v>, param_name: &str) -> Result<Self, Error>

Unpack value, but instead of None return error about incorrect named argument type.

impl Eq for Workflow

impl StructuralPartialEq for Workflow