Trait rocket_dyn_templates::minijinja::value::ObjectExt

pub trait ObjectExt:
    Object
    + Send
    + Sync
    + 'static {
    // Provided methods
    fn mapped_enumerator<F>(self: &Arc<Self>, maker: F) -> Enumerator
       where F: for<'a> FnOnce(&'a Self) -> Box<dyn Iterator<Item = Value> + Sync + Send + 'a> + Send + Sync + 'static,
             Self: Sized { ... }
    fn mapped_rev_enumerator<F>(self: &Arc<Self>, maker: F) -> Enumerator
       where F: for<'a> FnOnce(&'a Self) -> Box<dyn DoubleEndedIterator<Item = Value> + Sync + Send + 'a> + Send + Sync + 'static,
             Self: Sized { ... }
    fn try_iter(
        self: &Arc<Self>,
    ) -> Option<Box<dyn Iterator<Item = Value> + Sync + Send>>
       where Self: 'static { ... }
    fn try_iter_pairs(
        self: &Arc<Self>,
    ) -> Option<Box<dyn Iterator<Item = (Value, Value)> + Sync + Send>> { ... }
}

Provides utility methods for working with objects.

Provided Methods

fn mapped_enumerator<F>(self: &Arc<Self>, maker: F) -> Enumerator

where F: for<'a> FnOnce(&'a Self) -> Box<dyn Iterator<Item = Value> + Sync + Send + 'a> + Send + Sync + 'static, Self: Sized,

Creates a new iterator enumeration that projects into the given object.

It takes a method that is passed a reference to self and is expected to return an Iterator. This iterator is then wrapped in an Enumerator::Iter. This allows one to create an iterator that borrows out of the object.

Example

use std::sync::Arc;
use minijinja::value::{Value, Object, ObjectExt, Enumerator};

#[derive(Debug)]
struct CustomMap(HashMap<usize, i64>);

impl Object for CustomMap {
    fn get_value(self: &Arc<Self>, key: &Value) -> Option<Value> {
        self.0.get(&key.as_usize()?).copied().map(Value::from)
    }

    fn enumerate(self: &Arc<Self>) -> Enumerator {
        self.mapped_enumerator(|this| {
            Box::new(this.0.keys().copied().map(Value::from))
        })
    }
}

fn mapped_rev_enumerator<F>(self: &Arc<Self>, maker: F) -> Enumerator

where F: for<'a> FnOnce(&'a Self) -> Box<dyn DoubleEndedIterator<Item = Value> + Sync + Send + 'a> + Send + Sync + 'static, Self: Sized,

Creates a new reversible iterator enumeration that projects into the given object.

It takes a method that is passed a reference to self and is expected to return a DoubleEndedIterator. This iterator is then wrapped in an Enumerator::RevIter. This allows one to create an iterator that borrows out of the object and is reversible.

Example

use std::sync::Arc;
use std::ops::Range;
use minijinja::value::{Value, Object, ObjectExt, ObjectRepr, Enumerator};

#[derive(Debug)]
struct VecView(Vec<usize>);

impl Object for VecView {
    fn repr(self: &Arc<Self>) -> ObjectRepr {
        ObjectRepr::Iterable
    }

    fn enumerate(self: &Arc<Self>) -> Enumerator {
        self.mapped_enumerator(|this| {
            Box::new(this.0.iter().cloned().map(Value::from))
        })
    }
}

fn try_iter( self: &Arc<Self>, ) -> Option<Box<dyn Iterator<Item = Value> + Sync + Send>>

where Self: 'static,

Iterates over this object.

If this returns None then the default object iteration as defined by the object’s enumeration is used.

fn try_iter_pairs( self: &Arc<Self>, ) -> Option<Box<dyn Iterator<Item = (Value, Value)> + Sync + Send>>

Iterate over key and value at once.

Object Safety

This trait is not object safe.

Implementors

impl<T> ObjectExt for T

where T: Object + Send + Sync + 'static,