godprotocol 1.0.842 → 1.1.0

package/Executables/functions/folder.js

@@ -0,0 +1,95 @@
+const readone = (args, vm, options) =>{
+  let {query} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(query, (res)=>{
+    vm.air_object(fold.readone(res), options)
+  })
+}
+
+const read = (args, vm, options) =>{
+  let {query} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(query, (res)=>{
+    vm.air_object(fold.read(res), options)
+  })
+}
+
+const clean_check_folder = (args, vm)=>{
+  let {folder}= args;
+
+  let name = vm.read_chain(folder.name)
+  if(name.__classifier__ !== vm.get_type_address('string')){
+    return vm.stderr({name:'Type_error', message: "Folder name must be a string."})
+  }else name = vm.static_value(name);
+
+  let fold = vm.account.manager.oracle.gds.folder(name.static_value)
+
+  return {name, fold}
+}
+
+const write = (args, vm, options) =>{
+  let {data} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+  
+  vm.display(data, (res)=>{
+    vm.air_object(fold.write(res), options)
+  })
+}
+
+const write_several = (args, vm, options) =>{
+  let {data} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(data, (res)=>{
+    vm.air_object(fold.write_several(res), options)
+  })
+}
+
+
+const remove = (args, vm, options) =>{
+  let {query} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(query, (res)=>{
+    vm.air_object(fold.remove(res), options)
+  })
+}
+
+const remove_several = (args, vm, options) =>{
+  let {query} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(query, (res)=>{
+    vm.air_object(fold.remove_several(res), options)
+  })
+}
+
+const update = (args, vm, options) =>{
+  let {query} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(query, (res)=>{
+    vm.air_object(fold.update(res), options)
+  })
+}
+
+const update_several = (args, vm, options) =>{
+  let {query} = args;
+
+  let {fold} = clean_check_folder(args, vm)
+
+  vm.display(query, (res)=>{
+    vm.air_object(fold.update_several(res), options)
+  })
+}
+
+export {read, readone, update, update_several, write, write_several, remove, remove_several}

package/Executables/functions/folder_register.js

@@ -0,0 +1,87 @@
+import { read, readone, remove, remove_several, update, update_several, write, write_several } from "./folder";
+
+const folder_register = (account)=>{
+  let add_callable = account.vm.add_callable;
+
+  add_callable('read_', {
+    callable: read,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'query', position:1},
+      ]
+    }
+  })
+
+  add_callable('readone_', {
+    callable: readone,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'query', position:1},
+      ]
+    }
+  })
+
+  add_callable('update_', {
+    callable: update,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'query', position:1},
+      ]
+    }
+  })
+
+  add_callable('update_several_', {
+    callable: update_several,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'query', position:1},
+      ]
+    }
+  })
+
+  add_callable('write_several_', {
+    callable: write_several,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'data', position:1},
+      ]
+    }
+  })
+
+  add_callable('write', {
+    callable: write,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'data', position:1},
+      ]
+    }
+  })
+
+  add_callable('remove_several_', {
+    callable: remove_several,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'query', position:1},
+      ]
+    }
+  })
+
+  add_callable('remove', {
+    callable: remove,
+    config: {
+      parameters: [
+        {name:'folder', position:0},
+        {name:'query', position:1},
+      ]
+    }
+  })
+}
+
+export default folder_register

package/Executables/functions/importcheck.js

@@ -0,0 +1,13 @@
+const importcheck = (args, vm)=>{
+  console.log(args, 'importcheck.args')
+  let {names} = args;
+
+  if(!Array.isArray(names)) names = [names]
+
+  for (let n=0; n< names.length; n++){
+    let name = names[n]
+
+  }
+}
+
+export default importcheck

package/Executables/functions/indices.js

@@ -0,0 +1,56 @@
+
+
+const get = (args, vm, options)=>{
+  let{obj,prop}=args;
+
+  // console.log(args, 'get args')
+  if(!obj||!prop) return vm.stderr(`Invalid arguments in get.callable`)
+
+  if (obj.__classifier__ === vm.get_type_address('twain')){
+    let get_ = require('./methods/twain').get
+    return get_({twain: obj, prop}, vm, options)
+  }
+  prop = vm.static_value(prop)
+
+  if (prop.__print__){
+    vm.exec({executable: prop.__print__, location: (prop)=>{
+      
+      if(!prop.static_value)return this.stderr({name:'Type_error', message: "get.callables"})
+ 
+      let addr = obj[prop.static_value]
+      let result = vm.read_chain(addr)
+
+      vm.write_chain(result, options.location)
+      
+    }})
+  
+    return;
+  }
+  
+  let static_prop = prop.static_value
+  let addr = obj[static_prop]
+  let result = vm.read_chain(addr)
+
+  return {result, is_callable: !!(result.__address__ && vm.handle_chain(result.__address__).datapath)}
+}
+
+const set = (args, vm)=>{
+  let {obj, prop, value} = args;
+
+  // console.log(args, 'set args')
+  if(!obj || !prop || !value) return vm.stderr(`Invalid arguments in set.callable`)
+  
+  prop = vm.static_value(prop)
+  
+  let static_prop = prop.static_value
+  let val_addr = value.__address__
+  obj[static_prop] = val_addr;
+
+  vm.write_chain(obj, obj.__address__, {is_callable: !!vm.handle_chain(value.__address__).datapath})
+
+  return {
+    result: obj,
+  }
+}
+
+export {get, set}

package/Executables/functions/len.js

@@ -0,0 +1,22 @@
+const len = (args, vm, options) => {
+  let {object} = args;
+
+  if(![vm.get_type_address('string'),vm.get_type_address('array')].includes(object.__classifier__)){
+    if (object.__len__){
+      vm.exec({executable: object.__len__, location: result=>{
+        if (result.__classifier__ !== vm.get_type_address('number')){
+          return vm.stderr({name:'Type_error', message: `__len__ method should only return type of 'number'`})
+        }
+        
+        vm.write_chain(result, options.location)
+      }})
+    }else return vm.air_object(null, options)
+  }
+
+  let statics = vm.static_value(object)
+
+  vm.air_object(statics.static_value.length, options)
+}
+
+
+export default len

package/Executables/functions/methods/array.js

@@ -0,0 +1,272 @@
+import typecast from "../typecast";
+
+const insert = (args, vm, options) => {
+  let { arr, index, value } = args;
+
+  if (
+    !index ||
+    (index && index.__classifier__ !== vm.get_type_address("number"))
+  )
+    index = { static_value: undefined };
+  else index = vm.static_value(index);
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      if (index.static_value != undefined) {
+        result.static_value.splice(index.static_value, 0, value.__address__);
+      } else result.static_value = [...result.static_value, value.__address__];
+
+      vm.write_chain(result, result.__address__);
+
+      vm.air_object(result.static_value.length, options);
+    },
+  });
+};
+
+const pop = (args, vm, options) => {
+  let { arr, index } = args;
+
+  if (
+    !index ||
+    (index && index.__classifier__ !== vm.get_type_address("number"))
+  )
+    index = { static_value: undefined };
+  else index = vm.static_value(index);
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      let item;
+      if (
+        index.static_value != undefined ||
+        index.static_value >= result.static_value.length
+      ) {
+        item = result.static_value.splice(index.static_value, 1);
+        item = item[0];
+      } else item = result.static_value.pop();
+
+      vm.write_chain(result, result.__address__);
+
+      vm.write_chain(vm.read_chain(item), options.location);
+    },
+  });
+};
+
+const repeat = (args, vm, options) => {
+  let {arr, n} = args;
+
+  if (
+    !n ||
+    (n && n.__classifier__ !== vm.get_type_address("number"))
+  )
+    n = { static_value: 0 };
+  else n = vm.static_value(n);
+
+  vm.exec({executable: arr.__print__, location: result=>{
+    let og = result.static_value;
+    let sv = [...result.static_value];
+    
+    for (let i=0; i< n.static_value; i++){
+      sv.push(...og)
+    }
+    vm.write_chain({...result, static_value: sv}, result.__address__)
+    vm.write_chain(arr, options.location)
+  }})
+};
+
+const concat_ = (arr, other, index) => {
+  if (index === undefined || index > arr.length) {
+    index = arr.length;
+  }
+
+  let start = arr.slice(0, index);
+  let end = arr.slice(index);
+
+  arr = [...start, ...other, ...end];
+
+  return arr;
+};
+
+const concat = (args, vm, options) => {
+  let { spread } = options;
+  let { arr, other, index } = args;
+
+  if (other.__classifier__ !== vm.get_type_address("array")) {
+    other = typecast({
+      obj: vm.static_value(other),
+      typ: { static_value: "array" },
+    });
+  } else other = vm.static_value(other);
+  if (
+    !index ||
+    (index && index.__classifier__ !== vm.get_type_address("number"))
+  )
+    index = { static_value: undefined };
+  else index = vm.static_value(index);
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      let res = concat_(
+        result.static_value,
+        spread ? other.static_value : [other.static_value],
+        index.static_value
+      );
+      vm.write_chain({ ...result, static_value: res }, result.__address__);
+
+      vm.write_chain(arr, options.location);
+    },
+  });
+};
+
+const index = (args, vm, options) => {
+  let { arr, n } = args;
+
+  if (!n || (n && n.__classifier__ !== vm.get_type_address("number")))
+    return vm.air_object(null, options);
+  else n = vm.static_value(n);
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      if (n.static_value < 0 ||( n.static_value >= result.static_value.length))
+        return vm.air_object(null, options);
+
+      vm.write_chain(vm.read_chain(result.static_value[n.static_value]), options.location);
+    },
+  });
+};
+
+const slice = (args, vm, options) => {
+  let { arr, start, end } = args;
+
+  if (start.__classifier__ !== vm.get_type_address("number")) {
+    return { result: arr };
+  } else start = vm.static_value(start);
+
+  if (!end || (end && end.__classifier__ !== vm.get_type_address("number"))) {
+    end = { static_value: undefined };
+  } else end = vm.static_value(end);
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      let new_val = result.static_value.slice(
+        start.static_value,
+        end.static_value
+      );
+
+      vm.air_object(new_val, options);
+    },
+  });
+};
+
+const clear = (args, vm) => {
+  let { arr } = args;
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      result.static_value = [];
+      vm.write_chain(result, result.__address__);
+
+      vm.write_chain(arr, options.location);
+    },
+  });
+};
+
+const replace = (args, vm) => {
+  let { arr, index, value } = args;
+
+  if (
+    !index ||
+    (index && index.__classifier__ !== vm.get_type_address("number"))
+  )
+    return { result: arr };
+  else index = vm.static_value(index);
+
+  vm.exec({
+    executable: arr.__print__,
+    location: (result) => {
+      result.static_value.splice(index.static_value, 1, value.__address__);
+
+      vm.write_chain(result, result.__address__);
+
+      vm.write_chain(arr, options.location);
+    },
+  });
+};
+
+const find = (args, vm, options)=>{
+  let {index} = options;
+  let {arr, executable} = args;
+
+  // console.log(args, 'find.args')
+
+  vm.exec({executable: arr.__print__, location: result=>{
+    let stv = result.static_value;
+    
+    vm.exec({executable, metadata: {loop:{index:0, array: stv, conditioner: res=>{
+      res = vm.static_value(res)
+      return (res && res.static_value === true)
+    }}}, arguments:{argv:[{address: stv[0], position: 0}], argc:1}, location: (result, metadata)=>{
+      result = vm.static_value(result)
+      if(result.static_value=== true){
+        if (index){
+          vm.air_object(metadata.loop.index, options)
+        }else vm.write_chain(this.read_chain(stv[metadata.loop.index]), options.location)
+      }else {
+        vm.air_object(index? -1: null, options)
+      }
+    }})
+  }})
+}
+
+const filter = (args, vm, options)=>{
+  let {arr, executable} = args;
+
+  // console.log(args, 'filter.args')
+
+  vm.exec({executable: arr.__print__, location: result=>{
+    let stv = result.static_value;
+    let filts = []
+    
+    vm.exec({executable, metadata: {loop:{index:0, array: stv, conditioner: reslt=>{
+      let res = vm.static_value(reslt)
+      if (res && res.static_value === true){
+        filts.push(reslt)
+      }
+      return true
+    }}}, arguments:{argv:[{address: stv[0], position: 0}], argc:1}, location: (result, metadata)=>{
+      vm.air_object(filts, {...options, item_type:'static_object'})
+    }})
+  }})
+}
+
+const map = (args, vm, options)=>{
+  let {arr, executable} = args;
+
+  // console.log(args, 'map.args')
+
+  vm.exec({executable: arr.__print__, location: result=>{
+    let stv = result.static_value;
+    let mapped_values = []
+    
+    vm.exec({executable, metadata: {loop:{index:0, array: stv, conditioner: (res, metadata)=>{
+      mapped_values.push(res)
+      return metadata.loop.index+1 === stv.length
+    }}}, arguments:{argv:[{address: stv[0], position: 0}], argc:1}, location: (result)=>{
+
+      vm.air_object(mapped_values, {...options, item_type:'static_object'})
+
+    }})
+    
+  }})
+}
+
+const copy = (args, vm, options)=>{
+  let {arr, depth} = args;
+}
+
+export { pop, insert, repeat, map, concat, index, find, clear, slice, replace , filter, copy};