Struct Layer

pub struct Layer<S> { /* private fields */ }

A generic layer, which controls access to layer state

Layer is a generic wrapper around some state and controls access to it. It Derefs to the state it wraps, for easy read access, but prevents any direct write access.

Instead, each write access to state is reified as a command, which are processed by Layer::process. Processing a command can result in any number of events, which can then be used as commands for other layers.

This design takes inspiration from, and uses the nomenclature of, this article: https://thinkbeforecoding.com/post/2021/12/17/functional-event-sourcing-decider

Implementations

impl Layer<Geometry>

pub fn define_half_edge( &mut self, half_edge: Handle<HalfEdge>, geometry: HalfEdgeGeometry, )

Define the geometry of the provided half-edge

pub fn define_surface( &mut self, surface: Handle<Surface>, geometry: SurfaceGeometry, )

Define the geometry of the provided surface

impl Layer<Objects>

pub fn insert( &mut self, object: AnyObject<AboutToBeStored>, geometry: &Geometry, validation: &mut Layer<Validation>, )

Insert an object into the stores

Passes any events produced to the validation layer.

impl Layer<Presentation>

pub fn set_color(&mut self, region: Handle<Region>, color: Color)

Set the color of a region

pub fn derive_object( &mut self, original: AnyObject<Stored>, derived: AnyObject<Stored>, )

Mark an object as being derived from another

impl Layer<Validation>

pub fn take_errors(&mut self) -> Result<(), ValidationErrors>

Take all errors stored in the validation layer

impl<S> Layer<S>

pub fn new(state: S) -> Self

Create an instance of Layer

pub fn process<C>( &mut self, command: C, events: &mut Vec<C::Event>, ) -> C::Result

where C: Command<S>,

Process a command

The command is processed synchronously. When this method returns, the state has been updated.

pub fn into_state(self) -> S

Drop this instance, returning the wrapped state

Trait Implementations

impl<S> Default for Layer<S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<S> Deref for Layer<S>

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.