Struct tract_pulse::internal::tract_core::internal::SimplePlan

pub struct SimplePlan<F, O, M>where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,{
    pub model: M,
    pub outputs: Vec<OutletId, Global>,
    pub order: Vec<usize, Global>,
    pub flush_lists: Vec<SmallVec<[usize; 4]>, Global>,
    pub has_unresolved_symbols: bool,
    /* private fields */
}

Fields

model: M

outputs: Vec<OutletId, Global>

order: Vec<usize, Global>

flush_lists: Vec<SmallVec<[usize; 4]>, Global>

has_unresolved_symbols: bool

Implementations

impl<F, O, M> SimplePlan<F, O, M>where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,

pub fn new(model: M) -> Result<SimplePlan<F, O, M>, Error>

This contructor returns a plan that will compute all the model default outputs in one pass.

pub fn new_for_output(
    model: M,
    output: OutletId
) -> Result<SimplePlan<F, O, M>, Error>

This contructor returns a plan that will compute the specified output.

pub fn new_for_outputs(
    model: M,
    outputs: &[OutletId]
) -> Result<SimplePlan<F, O, M>, Error>

This contructor returns a plan that will compute all specified outputs in one pass.

pub fn new_for_outputs_and_deps(
    model: M,
    outputs: &[OutletId],
    deps: &[(usize, usize)]
) -> Result<SimplePlan<F, O, M>, Error>

pub fn run(
    &self,
    inputs: SmallVec<[TValue; 4]>
) -> Result<SmallVec<[TValue; 4]>, Error>

pub fn model(&self) -> &Graph<F, O>

Trait Implementations

impl<F, O, M> Clone for SimplePlan<F, O, M>where
    F: Clone + Fact + Hash + 'static,
    O: Clone + Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + 'static + Hash,
    M: Clone + Borrow<Graph<F, O>> + Hash,

fn clone(&self) -> SimplePlan<F, O, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, O, M> Debug for SimplePlan<F, O, M>where
    F: Debug + Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    M: Debug + Borrow<Graph<F, O>> + Hash,

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

Formats the value using the given formatter.

impl<F, O, M> Hash for SimplePlan<F, O, M>where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,

fn hash<H>(&self, state: &mut H)where
    H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.