feat: implement RadonOpCodes::MapPick

Author: guidiaz

rad/src/operators/map.rs

@@ -154,6 +154,48 @@ pub fn values(input: &RadonMap) -> RadonArray {
     let v: Vec<RadonTypes> = input.value().values().cloned().collect();
     RadonArray::from(v)
 }
+
+pub fn pick(input: &RadonMap, args: &[Value]) -> Result<RadonMap, RadError> {
+    let not_found = |key_str: &str| RadError::MapKeyNotFound { 
+        key: String::from(key_str) 
+    };
+    
+    let wrong_args = || RadError::WrongArguments {
+        input_type: RadonMap::radon_type_name(),
+        operator: "Pick".to_string(),
+        args: args.to_vec(),
+    };
+
+    let mut input_keys = vec![];
+    if args.len() > 1 {
+        return Err(wrong_args());
+    } else {
+        let first_arg = args.get(0).ok_or_else(wrong_args)?;
+        match first_arg {
+            Value::Array(keys) => {
+                for key in keys.iter() {
+                    let key_string = from_value::<String>(key.to_owned()).map_err(|_| wrong_args())?;
+                    input_keys.push(key_string);
+                }
+            }
+            Value::Text(key) => {
+                input_keys.push(key.clone());
+            }
+            _ => return Err(wrong_args())
+        };
+    }
+
+    let mut output_map = BTreeMap::<String, RadonTypes>::default();
+    for key in input_keys {
+        if let Some(value) = input.value().get(&key) {
+            output_map.insert(key, value.clone());
+        } else {
+            return Err(not_found(key.as_str()))
+        }
+    }
+    Ok(RadonMap::from(output_map))
+}
+
 pub fn stringify(input: &RadonMap) -> Result<RadonString, RadError> {
     let json_string = serde_json::to_string(&input.value())
         .map_err(|_| RadError::Decode { 

rad/src/operators/mod.rs

@@ -96,6 +96,7 @@ pub enum RadonOpCodes {
     MapValues = 0x69,
     //MapEntries = 0x6A,
     MapAlter = 0x6B,
+    MapPick = 0x6E,
     ///////////////////////////////////////////////////////////////////////
     // String operator codes (start at 0x70)
     StringAsBoolean = 0x70,

rad/src/types/map.rs

@@ -162,6 +162,7 @@ impl Operable for RadonMap {
             (RadonOpCodes::MapKeys, None) => Ok(RadonTypes::from(map_operators::keys(self))),
             (RadonOpCodes::MapValues, None) => Ok(RadonTypes::from(map_operators::values(self))),
             (RadonOpCodes::MapAlter, Some(args)) => map_operators::alter(self, args, context).map(RadonTypes::from),
+            (RadonOpCodes::MapPick, Some(args)) => map_operators::pick(self, args).map(RadonTypes::from),
             (RadonOpCodes::MapStringify, None) => map_operators::stringify(self).map(RadonTypes::from),
             (op_code, args) => Err(RadError::UnsupportedOperator {
                 input_type: RADON_MAP_TYPE_NAME.to_string(),