Struct Route 

pub struct Route;

Routes a bundle of wires through points picked in order — from the connector it starts at, through clips, to the connector it ends at — as a tangent-continuous chain of lines and arcs (see crate::route), and sweeps the bundle along it into a solid named route(R) for the operation R. A route that bends tighter than the bundle may is refused, naming the waypoints each bend lies between, its radius and the radius allowed.

What the bundle is cut from is recorded as the cable route(R) of the part’s cables (see Cable): every wire with its cut length, the route’s length and a service loop at each end.

The points may be of parts placed in the part: the route follows them wherever their mates put them, rerouted whenever the program runs.

The solid is named like any path sweep (see geop_lib_sweep::sweep_along): the profile is a circle of four arcs c0–c3 meeting at p0–p3, the path’s curves and joints are named as RoutePath says — route(R,c0,a1) is a quarter of the bundle’s skin along the first arc after the second waypoint — and its ends are route(R,start) and route(R,end).

Trait Implementations

impl Clone for Route

fn clone(&self) -> Route

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Route

impl Debug for Route

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

Formats the value using the given formatter.

impl Default for Route

fn default() -> Route

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Route

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for Route

const INFO: OperationInfo = <Route as ::geop_core_editor::part_operation::PartOperation>::INFO

type EditingState = FormState<<Route as PartOperation>::Session>

What the editor keeps about a step while it is edited, beyond its arguments, starting from the default whenever a step is opened.

fn new_args(context: &Context<'_>) -> Self::Args

The arguments of a new step: sensible defaults, taking the part it is inserted into into account.

fn presentation( context: &Context<'_>, args: &Self::Args, editing: &Self::EditingState, ) -> Form

What the editor shows while the step is edited. Never fails: an editor needs the form most exactly when the arguments do not build, so whatever is wrong is said in it.

fn process_user_event( context: &Context<'_>, args: &Self::Args, editing: &Self::EditingState, event: Event, ) -> (Self::Args, Self::EditingState)

The step’s arguments and editing state after event.

impl ModelOperation for Route

fn build( model: &mut NamedModel, reader: &Reader<'_>, step: &str, args: &RouteArgs, ) -> GeopResult<()>

The points are resolved in the part as the steps before left it.

impl Operation for Route

const KIND: &'static str = <Route as ::geop_core_editor::part_operation::PartOperation>::KIND

The name programs store its steps under.

type Args = <Route as PartOperation>::Args

What a step of the operation is given. It is saved with the program, so it names targets and elements, never holds their internal ids.

fn run(ctx: &mut StepContext<'_>, args: &Self::Args) -> __GeopResult<()>

Declares what the step produces, through ctx (see StepContext::produce): cheap, since it runs in every run. What takes work is done in the makes, which run only when what they read changed.

impl PartOperation for Route

fn new_args(_: &Context<'_>) -> RouteArgs

Nothing picked yet; one hookup wire, filling three quarters of the bundle, bent no tighter than five diameters.

fn run(ctx: &mut StepContext<'_>, args: &RouteArgs) -> GeopResult<()>

Sweeps the bundle, then records its cable, and notes the bundle.

const KIND: &'static str = "route"

The name programs store its steps under.

const INFO: OperationInfo

type Args = RouteArgs

What a step is given. It is saved with the program, so it names targets and elements, never holds their internal ids.

type Session = RouteSession

What the editor keeps while a step is edited besides its arguments and the visuals selected: () for most.

fn form<'a>( context: &'a Context<'a>, args: &RouteArgs, editing: &RouteEditing, ) -> EditForm<'a, RouteArgs, RouteSession>

What the editor shows while the step is edited, with what setting each field does. Never fails: an editor needs the form most exactly when the arguments do not build, so whatever is wrong is said in it.

fn begin_event(session: &mut Self::Session)

What the session forgets at the start of every event, before the event is handled: nothing, by default.

fn canvas( context: &Context<'_>, edit: Edit<'_, Self::Args, Self::Session>, event: &CanvasEvent, )

What the pointer or a key did on the canvas: nothing, by default.

impl PartialEq for Route

fn eq(&self, other: &Route) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Route

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 Route