Trait interact::ReflectDirect

pub trait ReflectDirect {
    fn immut_reflector(&self, _reflector: &Arc<Reflector>) -> NodeTree;
    fn immut_climber<'a>(
        &self, 
        _climber: &mut Climber<'a>
    ) -> Result<Option<NodeTree>, ClimbError>;
    fn mut_climber<'a>(
        &mut self, 
        _climber: &mut Climber<'a>
    ) -> Result<Option<NodeTree>, ClimbError>;
}

The direct Reflect allows direct climber or reflector access, and meant to be used as a trait object for that purpose.

Required methods

fn immut_reflector(&self, _reflector: &Arc<Reflector>) -> NodeTree

The specific implementation of the following method will mostly likely call Reflector::reflect with the specific type.

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

Implement climbing for the specific type. Returns a reflection of the inner value, depending on the expression remaining to parse.

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

Implement mutable climbing for the specific type, allowing to modifying it. Returns a reflection of the inner value, depending on the expression remaining to parse.

Loading content...

Implementations on Foreign Types

impl ReflectDirect for usize

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for u64

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for u32

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for u16

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for u8

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for isize

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for bool

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for String

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for char

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for i64

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for i32

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for i16

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for i8

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<K, V> ReflectDirect for BTreeMap<K, V> where
    K: Eq + Ord + Access + Deser,
    V: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T: Access> ReflectDirect for Option<T>

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T: Access, E: Access> ReflectDirect for Result<T, E>

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<K, V, S> ReflectDirect for HashMap<K, V, S> where
    K: Eq + Hash + Access + Deser,
    V: Access,
    S: BuildHasher, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<K, S> ReflectDirect for HashSet<K, S> where
    K: Eq + Hash + Access,
    S: BuildHasher, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for Instant

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for Mutex<T> where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for RefCell<T> where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for (T,) where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl ReflectDirect for ()

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    _climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B> ReflectDirect for (A, B) where
    A: Access,
    B: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C> ReflectDirect for (A, B, C) where
    A: Access,
    B: Access,
    C: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D> ReflectDirect for (A, B, C, D) where
    A: Access,
    B: Access,
    C: Access,
    D: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D, E> ReflectDirect for (A, B, C, D, E) where
    A: Access,
    B: Access,
    C: Access,
    D: Access,
    E: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D, E, F> ReflectDirect for (A, B, C, D, E, F) where
    A: Access,
    B: Access,
    C: Access,
    D: Access,
    E: Access,
    F: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D, E, F, G> ReflectDirect for (A, B, C, D, E, F, G) where
    A: Access,
    B: Access,
    C: Access,
    D: Access,
    E: Access,
    F: Access,
    G: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D, E, F, G, H> ReflectDirect for (A, B, C, D, E, F, G, H) where
    A: Access,
    B: Access,
    C: Access,
    D: Access,
    E: Access,
    F: Access,
    G: Access,
    H: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D, E, F, G, H, I> ReflectDirect for (A, B, C, D, E, F, G, H, I) where
    A: Access,
    B: Access,
    C: Access,
    D: Access,
    E: Access,
    F: Access,
    G: Access,
    H: Access,
    I: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<A, B, C, D, E, F, G, H, I, J> ReflectDirect for (A, B, C, D, E, F, G, H, I, J) where
    A: Access,
    B: Access,
    C: Access,
    D: Access,
    E: Access,
    F: Access,
    G: Access,
    H: Access,
    I: Access,
    J: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T, '_> ReflectDirect for &'_ [T] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T, '_> ReflectDirect for &'_ mut [T] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for Vec<T> where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 1] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 2] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 3] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 4] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 5] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 6] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 7] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 8] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 9] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 10] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 11] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 12] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 13] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 14] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 15] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 16] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 17] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 18] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 19] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 21] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 22] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 23] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 24] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 25] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 27] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 28] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 29] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 31] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

impl<T> ReflectDirect for [T; 32] where
    T: Access, 

fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree

fn immut_climber<'a>(
    &self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

fn mut_climber<'a>(
    &mut self,
    climber: &mut Climber<'a>
) -> Result<Option<NodeTree>, ClimbError>

Loading content...

Implementors

Loading content...