Struct Program 

pub struct Program<O> {
    pub steps: Vec<Step<O>>,
}

A recipe for building a Part: an ordered list of steps, each referring to what earlier ones built only by name. Those names come from step ids and sketch element ids, never from the internal ids a build happens to assign (see geop_ops), so a program means the same thing every time it is run — including after a round trip through JSON.

Fields

steps: Vec<Step<O>>

Implementations

impl<O: Operations> Program<O>

pub fn new() -> Self

pub fn push(&mut self, id: impl Into<String>, operation: impl Into<O>)

Appends the step id: operation with its arguments.

pub fn index_of(&self, id: &str) -> GeopResult<usize>

The position of step id.

pub fn fresh_id(&self, operation: &O) -> String

An id no step has yet, for a new step running operation: its label, lowercased, and the lowest number that makes it unique — sketch1, extrude2.

pub fn validate(&self) -> GeopResult<()>

Checks that every step id is a valid operation id and unique: every name a step creates is built from its id.

pub fn build<S: Scalar>(&self) -> GeopResult<Part<S>>

Runs every step in order, starting from an empty part, and returns the part the whole program builds — or the first error any step raises, at which point the steps after it never run. A program always starts from nothing: its names are only guaranteed to be unique, and to mean the same thing on every run, when every entity was created by one of its own steps.

After each step, every entity of the part must have a name — an operation that leaves one unnamed has broken the one guarantee a program relies on.

pub fn to_json(&self) -> GeopResult<String>

The program as pretty-printed JSON: one step per object, every sketch entity keyed by its id, so edits show up as small line diffs.

pub fn from_json(json: &str) -> GeopResult<Self>

Trait Implementations

impl<O: Clone> Clone for Program<O>

fn clone(&self) -> Program<O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Debug> Debug for Program<O>

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

Formats the value using the given formatter.

impl<O> Default for Program<O>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, O> Deserialize<'de> for Program<O>

where O: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<O: PartialEq> PartialEq for Program<O>

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

where O: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<O: PartialEq> StructuralPartialEq for Program<O>