Struct GenericEngine 

pub struct GenericEngine<A, R> { /* private fields */ }

Typed storage and observable plumbing shared by concrete engines.

Mirrors the C++ GenericEngine<ArgumentsType, ResultsType>: carries the argument and result bundles and the engine’s observable, plus the observer half (the C++ update() { notifyObservers(); }) as a forwarder to register with the engine’s inputs via register_with. A concrete engine embeds one, delegates its PricingEngine accessors to it, and only implements calculate.

Implementations

impl<A: Arguments, R: Results> GenericEngine<A, R>

pub fn new(arguments: A, results: R) -> Self

Creates the engine base around its argument and result bundles.

pub fn arguments(&self) -> &A

The typed argument bundle.

pub fn arguments_mut(&mut self) -> &mut A

Mutable access to the typed argument bundle.

pub fn results(&self) -> &R

The typed result bundle.

pub fn results_mut(&mut self) -> &mut R

Mutable access to the typed result bundle.

pub fn reset(&mut self)

Clears the results ahead of a calculation.

pub fn register_with(&self, source: &Observable) -> bool

Registers the engine as an observer of source, so the source’s notifications are forwarded to the engine’s own observers (the C++ registerWith on an engine input).

pub fn observer(&self) -> SharedMut<dyn Observer>

The engine as an observer, for registering with an input that exposes only observer registration (the C++ registerWith on a Handle).

Trait Implementations

impl<A, R> AsObservable for GenericEngine<A, R>

fn observable(&self) -> &Observable

Access to the embedded observable for registering observers.