Enum InstructionKind 

pub enum InstructionKind {
    ApiRequest(ApiRequest),
    ImportFiles(ImportFiles),
    SetPrimitive {
        address: Address,
        value: Primitive,
    },
    SetValue {
        address: Address,
        value_parts: Vec<Primitive>,
    },
    AddrOfMember {
        start: Operand,
        member: Operand,
    },
    SetList {
        start: Address,
        elements: Vec<Vec<Primitive>>,
    },
    BinaryArithmetic {
        arithmetic: BinaryArithmetic,
        destination: Destination,
    },
    UnaryArithmetic {
        arithmetic: UnaryArithmetic,
        destination: Destination,
    },
    StackPush {
        data: Vec<Primitive>,
    },
    StackPop {
        destination: Option<Destination>,
    },
    StackExtend {
        data: Vec<Primitive>,
    },
    Copy {
        source: Address,
        length: usize,
        destination: Destination,
    },
    CopyLen {
        source_range: Operand,
        destination_range: Operand,
    },
    SketchGroupSet {
        sketch_group: SketchGroup,
        destination: usize,
    },
    SketchGroupAddSegment {
        segment: InMemory,
        source: usize,
        destination: usize,
    },
    SketchGroupSetBasePath {
        source: usize,
        from: InMemory,
        to: InMemory,
        name: Option<InMemory>,
    },
    SketchGroupCopyFrom {
        source: usize,
        offset: usize,
        length: usize,
        destination: Destination,
    },
    SketchGroupGetLastPoint {
        source: usize,
        destination: Destination,
    },
    NoOp {
        comment: String,
    },
    TransformImportFiles {
        source_import_files_response: InMemory,
        source_file_paths: InMemory,
        destination: Destination,
    },
}

One step of the execution plan.

Variants

ApiRequest(ApiRequest)

Call the KittyCAD API.

ImportFiles(ImportFiles)

Import a geometry file.

SetPrimitive

Set a primitive to a memory address.

Fields

address: Address

Which memory address to set.

value: Primitive

What value to set the memory address to.

SetValue

Lay out a multi-address value in memory.

Fields

address: Address

Which memory address to set.

value_parts: Vec<Primitive>

What values to put into memory.

AddrOfMember

Find an element/property of an array/object. Push the element/property’s address onto the stack. Assumes the object/list is formatted according to Self::SetList documentation.

Fields

start: Operand

Starting address of the array/object.

member: Operand

Element index or property name.

SetList

Set a list of elements into memory.

Format

Lists have this format (each line represents a memory address starting at start):

<number of elements>
<n = size of element 0>
<element 0, address 0>
<...>
<element 0, address n>
<n = size of element 1>
<element 1, address 0>
<...>
<element 1, address n>

etc etc for each element.

Fields

start: Address

List will start at this element.

elements: Vec<Vec<Primitive>>

Each element

BinaryArithmetic

Perform arithmetic on values in memory.

Fields

arithmetic: BinaryArithmetic

What to do.

destination: Destination

Write the output to this memory address.

UnaryArithmetic

Perform arithmetic on a value in memory.

Fields

arithmetic: UnaryArithmetic

What to do.

destination: Destination

Write the output to this memory address.

StackPush

Push this data onto the stack.

Fields

data: Vec<Primitive>

Data that will be pushed.

StackPop

Pop data off the stack into memory.

Fields

destination: Option<Destination>

If Some, the value popped will be stored at the destination. If None, the value won’t be stored anywhere.

StackExtend

Add the given primitives to whatever is on top of the stack. If the stack is empty, runtime error.

Fields

data: Vec<Primitive>

Extend whatever is on top of the stack with this new data.

Copy

Copy from one address to the other.

Fields

source: Address

Copy from here.

length: usize

How many addresses to copy.

destination: Destination

Copy to here.

CopyLen

Copy data from a range of addresses, into another range of addresses. The first address in the source range is the length (how many addresses to copy). If that address contains a uint, that uint is the length. If that address contains a List/Object header, the size field is the length. Source range is evaluated before destination range (this is only relevant if both source and destination come from the stack).

Fields

source_range: Operand

Start copying from this address.

destination_range: Operand

Start copying into this address.

SketchGroupSet

Write the SketchGroup to its special storage.

Fields

sketch_group: SketchGroup

What to write.

destination: usize

Index into the SketchGroup storage vec.

SketchGroupAddSegment

Add a path to a SketchGroup.

Fields

segment: InMemory

Address of a PathSegment which will be added to the SketchGroup.

source: usize

Where the SketchGroup to modify begins. This is an index into the SketchGroup storage of the memory.

destination: usize

Where the modified SketchGroup should be written to.

SketchGroupSetBasePath

Set the base path of a SketchGroup.

Fields

source: usize

Where the SketchGroup to modify begins. This is an index into the SketchGroup storage of the memory.

from: InMemory

Where the base path starts.

to: InMemory

Where the base path ends.

name: Option<InMemory>

The name of the base path.

SketchGroupCopyFrom

Copy data from a SketchGroup.

Fields

source: usize

Index into the SketchGroup array.

offset: usize

Which offset into the SketchGroup’s Vec should copying start at?

length: usize

How many primitives should be copied?

destination: Destination

Where to copy them to.

SketchGroupGetLastPoint

Get the to end of the last path segment, i.e. the point from which the next segment will start.

Fields

source: usize

Which SketchGroup to examine.

destination: Destination

Where to copy the data.

NoOp

Does nothing. Used for debugging.

Fields

comment: String

Debug message.

TransformImportFiles

Transform the response of an API call to ImportFiles, into an OkWebSocketResponse::ImportGeometry.

Fields

source_import_files_response: InMemory

Where the API response was stored. Read first.

source_file_paths: InMemory

Where the filenames are stored. Read second.

destination: Destination

Where to write the ImportGeometry.

Implementations

impl InstructionKind

pub async fn execute( self, mem: &mut Memory, session: &mut Option<Session>, events: &mut EventWriter, batch_queue: &mut ModelingBatch, ) -> Result<(), ExecutionError>

Execute the instruction

Trait Implementations

impl Clone for InstructionKind

fn clone(&self) -> InstructionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InstructionKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InstructionKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<InstructionKind> for Instruction

fn from(kind: InstructionKind) -> Self

Converts to this type from the input type.

impl PartialEq for InstructionKind

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for InstructionKind