Method invoke

lib/dsc-lib/src/parser/expressions.rs:129–231

Invoke the expression. # Arguments `function_dispatcher` - The function dispatcher to use. `context` - The context to use. # Returns The result of the expression. # Errors This function will return an error if the expression fails to execute.

(&self, function_dispatcher: &FunctionDispatcher, context: &Context)

    ///
    /// This function will return an error if the expression fails to execute.
    pub fn invoke(&self, function_dispatcher: &FunctionDispatcher, context: &Context) -> Result<Value, DscError> {
        let result = self.function.invoke(function_dispatcher, context)?;
        if self.function.name() != "secret" && !is_secure_value(&result) {
            let result_json = serde_json::to_string(&result)?;
            trace!("{}", t!("parser.expression.functionResult", results = result_json));
        } else {
            trace!("{}", t!("parser.expression.functionResultSecure"));
        }
        if self.accessors.is_empty() {
            Ok(result)
        }
        else {
            debug!("{}", t!("parser.expression.evalAccessors"));
            let mut value = result;
            let is_secure = is_secure_value(&value);
            if is_secure {
                // if a SecureString, extract the string value
                if let Some(string) = value.get("secureString") {
                    if let Some(s) = string.as_str() {
                        value = Value::String(s.to_string());
                    }
                } else if let Some(obj) = value.get("secureObject") {
                    // if a SecureObject, extract the object value
                    value = obj.clone();
                }
            }
            for accessor in &self.accessors {
                let mut index = Value::Null;
                match accessor {
                    Accessor::Member(member) => {
                        debug!("{}", t!("parser.expression.evaluatingMemberAccessor", name = member : {:?}));
                        if let Some(object) = value.as_object() {
                            if !object.contains_key(member) {
                                warn!("{}", t!("parser.expression.memberNameNotFound", member = member));
                                return Err(DscError::Parser(t!("parser.expression.memberNameNotFound", member = member).to_string()));
                            }
                            if is_secure {
                                value = convert_to_secure(&object[member]);
                            } else {
                                value = object[member].clone();
                            }
                        } else {
                            warn!("{}", t!("parser.expression.accessOnNonObject"));
                            return Err(DscError::Parser(t!("parser.expression.accessOnNonObject").to_string()));
                        }
                    },
                    Accessor::Index(index_value) => {
                        debug!("{}", t!("parser.expression.evaluatingIndexAccessor", index = index_value : {:?}));
                        if is_secure {
                            index = convert_to_secure(index_value);
                        } else {
                            index = index_value.clone();
                        }
                    },
                    Accessor::IndexExpression(expression) => {
                        debug!("{}", t!("parser.expression.evaluatingIndexExpression", expression = expression : {:?}));
                        index = expression.invoke(function_dispatcher, context)?;
                        trace!("{}", t!("parser.expression.expressionResult", index = index : {:?}));