Merge branch 'master' into namespace

src/api.rs

@@ -1,7 +1,7 @@
 //! Module that defines the extern API of `Engine`.
 
 use crate::any::{Dynamic, Variant};
-use crate::engine::{make_getter, make_setter, Engine, Map, State};
+use crate::engine::{make_getter, make_setter, Engine, Map, State, FUNC_INDEXER};
 use crate::error::ParseError;
 use crate::fn_call::FuncArgs;
 use crate::fn_register::RegisterFn;
@@ -43,6 +43,16 @@ pub trait ObjectSetCallback<T, U>: Fn(&mut T, U) + 'static {}
 #[cfg(not(feature = "sync"))]
 impl<F: Fn(&mut T, U) + 'static, T, U> ObjectSetCallback<T, U> for F {}
 
+#[cfg(feature = "sync")]
+pub trait ObjectIndexerCallback<T, X, U>: Fn(&mut T, X) -> U + Send + Sync + 'static {}
+#[cfg(feature = "sync")]
+impl<F: Fn(&mut T, X) -> U + Send + Sync + 'static, T, X, U> ObjectIndexerCallback<T, X, U> for F {}
+
+#[cfg(not(feature = "sync"))]
+pub trait ObjectIndexerCallback<T, X, U>: Fn(&mut T, X) -> U + 'static {}
+#[cfg(not(feature = "sync"))]
+impl<F: Fn(&mut T, X) -> U + 'static, T, X, U> ObjectIndexerCallback<T, X, U> for F {}
+
 #[cfg(feature = "sync")]
 pub trait IteratorCallback:
     Fn(Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + Send + Sync + 'static
@@ -300,6 +310,54 @@ impl Engine {
         self.register_set(name, set_fn);
     }
 
+    /// Register an indexer function for a registered type with the `Engine`.
+    ///
+    /// The function signature must start with `&mut self` and not `&self`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[derive(Clone)]
+    /// struct TestStruct {
+    ///     fields: Vec<i64>
+    /// }
+    ///
+    /// impl TestStruct {
+    ///     fn new() -> Self                { TestStruct { fields: vec![1, 2, 3, 4, 5] } }
+    ///
+    ///     // Even a getter must start with `&mut self` and not `&self`.
+    ///     fn get_field(&mut self, index: i64) -> i64 { self.fields[index as usize] }
+    /// }
+    ///
+    /// # fn main() -> Result<(), Box<rhai::EvalAltResult>> {
+    /// use rhai::{Engine, RegisterFn};
+    ///
+    /// let mut engine = Engine::new();
+    ///
+    /// // Register the custom type.
+    /// engine.register_type::<TestStruct>();
+    ///
+    /// engine.register_fn("new_ts", TestStruct::new);
+    ///
+    /// // Register an indexer.
+    /// engine.register_indexer(TestStruct::get_field);
+    ///
+    /// assert_eq!(engine.eval::<i64>("let a = new_ts(); a[2]")?, 3);
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(not(feature = "no_object"))]
+    #[cfg(not(feature = "no_index"))]
+    pub fn register_indexer<T, X, U, F>(&mut self, callback: F)
+    where
+        T: Variant + Clone,
+        U: Variant + Clone,
+        X: Variant + Clone,
+        F: ObjectIndexerCallback<T, X, U>,
+    {
+        self.register_fn(FUNC_INDEXER, callback);
+    }
+
     /// Compile a string into an `AST`, which can be used later for evaluation.
     ///
     /// # Example