Skip to main content

ReflectDirect

Trait ReflectDirect 

Source
pub trait ReflectDirect {
    // Required methods
    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>;
}
Expand description

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

Required Methods§

Source

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.

Source

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.

Source

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.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

Source§

impl ReflectDirect for ()

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for Instant

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for String

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for bool

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for char

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for i8

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for i16

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for i32

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for i64

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for isize

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for u8

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for u16

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for u32

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for u64

Source§

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

Source§

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

Source§

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

Source§

impl ReflectDirect for usize

Source§

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

Source§

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

Source§

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

Source§

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,

Source§

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

Source§

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

Source§

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

Source§

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,

Source§

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

Source§

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

Source§

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

Source§

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,

Source§

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

Source§

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

Source§

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

Source§

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,

Source§

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

Source§

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

Source§

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

Source§

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,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Implementors§