Trait dager::inport::InSignature

pub trait InSignature {
    pub fn has_edge(&self, idx: usize) -> bool;
    pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>;
    pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>;
    pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>;
    pub fn all_set(&self) -> bool;
}

Required methods

pub fn has_edge(&self, idx: usize) -> bool

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn all_set(&self) -> bool

Loading content...

Implementations on Foreign Types

impl InSignature for ()

pub fn has_edge(&self, _idx: usize) -> bool

pub fn set(&mut self, _idx: usize, _value: Box<dyn Any>) -> Result<(), DErr>

pub fn set_edge(&mut self, _edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, _port_idx: usize) -> Result<Edge, DErr>

pub fn all_set(&self) -> bool

impl<A, B> InSignature for (InCol<A>, InCol<B>) where
    A: Send + 'static,
    B: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C> InSignature for (InCol<A>, InCol<B>, InCol<C>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>, InCol<U>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static,
    U: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>, InCol<U>, InCol<V>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static,
    U: Send + 'static,
    V: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>, InCol<U>, InCol<V>, InCol<W>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static,
    U: Send + 'static,
    V: Send + 'static,
    W: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>, InCol<U>, InCol<V>, InCol<W>, InCol<X>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static,
    U: Send + 'static,
    V: Send + 'static,
    W: Send + 'static,
    X: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>, InCol<U>, InCol<V>, InCol<W>, InCol<X>, InCol<Y>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static,
    U: Send + 'static,
    V: Send + 'static,
    W: Send + 'static,
    X: Send + 'static,
    Y: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> InSignature for (InCol<A>, InCol<B>, InCol<C>, InCol<D>, InCol<E>, InCol<F>, InCol<G>, InCol<H>, InCol<I>, InCol<J>, InCol<K>, InCol<L>, InCol<M>, InCol<N>, InCol<O>, InCol<P>, InCol<Q>, InCol<R>, InCol<S>, InCol<T>, InCol<U>, InCol<V>, InCol<W>, InCol<X>, InCol<Y>, InCol<Z>) where
    A: Send + 'static,
    B: Send + 'static,
    C: Send + 'static,
    D: Send + 'static,
    E: Send + 'static,
    F: Send + 'static,
    G: Send + 'static,
    H: Send + 'static,
    I: Send + 'static,
    J: Send + 'static,
    K: Send + 'static,
    L: Send + 'static,
    M: Send + 'static,
    N: Send + 'static,
    O: Send + 'static,
    P: Send + 'static,
    Q: Send + 'static,
    R: Send + 'static,
    S: Send + 'static,
    T: Send + 'static,
    U: Send + 'static,
    V: Send + 'static,
    W: Send + 'static,
    X: Send + 'static,
    Y: Send + 'static,
    Z: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn all_set(&self) -> bool

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

Loading content...

Implementors

impl<A> InSignature for InCol<A> where
    A: Send + 'static, 

pub fn has_edge(&self, idx: usize) -> bool

pub fn set(&mut self, idx: usize, value: Box<dyn Any>) -> Result<(), DErr>

pub fn set_edge(&mut self, edge: Edge) -> Result<(), DErr>

pub fn remove_edge(&mut self, port_idx: usize) -> Result<Edge, DErr>

pub fn all_set(&self) -> bool

Loading content...