godprotocol 1.1.1 → 1.1.3

package/Datatypes/arr.js

@@ -1,30 +1,284 @@
-import Storage from 'godprotocol/Datatypes/objects/storage'
+import Storage from "./functions/storage";
 
-const arr = (args, vm, options)=>{
-  let {value} = args;
+class Arr extends Storage {
+  constructor(payload, manager) {
+    super(payload.config, manager);
 
- Storage.cold_store(value, vm, options)
-}
+    this.instance_object = payload;
+    this.value = payload.value
+    this.type = 'array'
+  }
 
+  call = async (name, args, options={})=>{
+    let {config, chain} = options;
+    let result, other, me =  await this.statics_()
 
-class Arr extends Storage{
-  constructor(value, vm){
-    super()
+    other = args[0] && await args[0].statics_()
     
-    this.value = value
-    this.vm = vm
+    let spli = this.value.value.split('/');
+    let config_hash = spli.slice(-1)[0], store;
+
+    switch(name){
+      case 'push':
+        result = me.push( await this.account.vm.instance_address(other))
+        store = true;
+
+        break;
+      case 'length':
+        result = me.length;
+        break;
+      case 'pop':
+        if (other){
+          result = me.splice(other, 1)[0]
+        }else result = me.pop()
+        
+        store= true
+
+        if(result){
+          result = {type:'address',value: result}
+        }
+        break
+      case 'extend':
+        result = me.push(...other)
+        store = true
+        
+        break;
+      case 'slice':
+        let start = args[0] && await args[0].literal()
+        let end = args[1] && await args[1].literal()
+
+        let new_arr = me.slice(start, end)
+        result = new_arr
+        break;
+      case 'splice':
+        let spl_replacement = args[2] && await args[2].statics_()
+        if (spl_replacement){
+          result = me.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal(), await await this.account.vm.instance_address(spl_replacement) )
+        }else result = me.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal())
+        
+        store = true;
+        break;
+      case 'replace':
+        me[await args[0].literal()] = await this.account.vm.instance_address(await args[1].statics_())
+        store = true;
+        break
+      case 'index':
+        let i = args[0] && await args[0].literal()
+        if (i< 0){
+          result = me.slice(i)[0]
+        }else result = me[i]
+        if (result)result = {type:'address', value: result}
+        else result = null
+        break;
+      case 'copy':
+        result = me;
+        break;
+      case 'deepcopy':
+        break;
+      case 'reverse':
+        me = [...me].reverse()
+        result = {type:'address', value: await this.account.vm.instance_address(this.instance_object)}
+
+        if (other){
+          store = true;
+        }else {
+          result = me
+        }
+        break;
+      case "is_empty":
+        result = !me.length
+        break;
+      case 'clear':
+        me = []
+        store = true;
+        break;
+      case 'join':
+        let str_val = ''
+        let separator = (other && await args[0].literal()) || ','
+        for (let i=0; i< me.length; i++){
+          let item = me[i]
+          let val = await this.account.vm.cloth_object(item)
+
+          if (['number', 'string', 'void', 'boolean'].includes(val.type))str_val = `${str_val}${i ? separator: ''}${await val.literal()}`
+        }
+        result = str_val
+        break;
+      case 'repeat':
+        me = Array.from({ length: other? await args[0].literal(): 0 }, () => me).flat()
+        
+        store = true;
+        result = me.length;
+        break;
+      case 'padstart':
+        let p_length = args[0] && await args[0].literal()
+        let value = args[1] && args[1]
+        if (me.length >= p_length){ me = me;
+        }else {
+          let padding = Array(p_length - me.length).fill(['array', 'twain'].includes(value && value.type) ? value.value.address : value.instance_object.address);
+          me = [...padding, ...me];
+          
+          store = true;
+        }
+        result = {type:'address', value: await this.account.vm.instance_address(this.instance_object)}
+
+        break;
+      case 'padend':
+        let ps_length = args[0] && await args[0].literal()
+        let svalue = args[1] && args[1]
+        if (me.length >= ps_length) {me = me;
+        }else {
+          let spadding = Array(ps_length - me.length).fill(['array', 'twain'].includes(svalue && svalue.type) ? svalue.value.address : svalue.instance_object.address);
+          me = [...me, ...spadding];
+          
+          store = true;
+        }
+        result = {type:'address', value: await this.account.vm.instance_address(this.instance_object)}
+        
+        break;
+      case 'to_string':
+        let str = ''
+        if(other){
+          other = await args[0].literal()
+        }
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let val = await this.account.vm.cloth_object(item)
+          if (other === 'ascii'){
+            if (val.type!=='number'){
+              str = `${str}void`
+            }else {
+              val = await val.literal()
+              str = `${str}${String.fromCharCode(val)}`
+            }
+          }
+        }
+        result = str
+        break;
+      case 'map':
+        result = new Array()
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain})
+
+          result[a] = res.type === 'instance' ? res.address : res.value
+        }
+        break;
+      case 'findindex':
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain, cloth: true})
+
+          if(await res.literal()){
+            result = a
+            break
+          }
+        }
+        if (result == null)result = -1
+        break;
+      case 'find':
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain, cloth: true})
+
+          if(await res.literal()){
+            result = {type:'address', value: res. type === 'instance'? res.address: res.value}
+            break
+          }
+        }
+        break;
+      case 'filter':
+        result = []
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain, cloth: true})
+
+          if(await res.literal()){
+            result.push(item)
+          }
+        }
+        break
+      case 'includes':
+        if(!['number', 'string', 'void', 'boolean'].includes(other.type)) result = false;
+        else {
+          let search = other? await args[0].literal(): null
+          if (!other)result = false;
+          else {
+            for (let a=0; a< me.length; a++){
+              let item = me[a]
+              let obj = await this.account.vm.cloth_object(item)
+    
+              if(['array', 'twain'].includes(obj.type)){
+                result = false
+              }
+              else if(await obj.literal() === search){
+                result = true;
+                break
+              }else result = false
+            }
+          }          
+        }
+        
+    }
+    if(store){
+      await this.account.manager.oracle.write(spli.slice(0,-1).join('/'), {type: this.type, values: me}, {config_hash, config: true})
+    }
+
+    return result
   }
 
-  literal = ()=>{
-    return this.value.map(val=>{
-      return this.vm.account.cloth_object(this.vm.read_chain(val)).literal()
-    })
+  configs = (name)=>{
+    let conf = {push: {
+      parameters: [{name: 'item', position: 0}]
+    }}
+
+    return conf[name]
   }
 
-  store = (options)=>{
-    Storage.cold_store(this.value, this.vm, options)
+  push = async({item})=>{
+    if (!item)return null;
+
+    let path = this.config.path;
+    
+    this.value.push(item.to_static())
+
+    this.config.content = this.to_static()
+
+    await this.manager.oracle.fs.write(path, JSON.stringify(this.config))
+    
+    return this.value.length;
   }
 }
 
-export default Arr
-export {arr}
+export default Arr;

package/Datatypes/bool.js

@@ -1,25 +1,13 @@
-import Storage from './objects/storage'
-
-const bool = (args, vm, options)=>{
-  let {value} = args;
-
-  if (value.static_address) value = vm.literal(value)
-  
-  let obj = new Bool(!!value, vm)
-  obj.store()
-
-  vm.air_object(obj, options)
-}
+import Storage from "./functions/storage";
 
 class Bool extends Storage {
-  constructor(value, vm){
-    super()
+  constructor(payload, account) {
+    super(payload.config, account);
 
-    this.value = value;
-    this.vm = vm
+    this.instance_object = payload.value;
+    this.value = JSON.parse(payload.value.value)
+    this.type = 'boolean'
   }
-
 }
 
-export default Bool
-export {bool}
+export default Bool;

package/Datatypes/callable.js

@@ -0,0 +1,12 @@
+import Storage from "./functions/storage";
+
+class Callable extends Storage {
+  constructor(payload, account) {
+    super(payload.config, account);
+
+    this.value = payload.value;
+    this.type = 'callable'
+  }
+}
+
+export default Callable;

package/Datatypes/cls.js

@@ -0,0 +1,41 @@
+import Storage from "./functions/storage";
+
+class Cls extends Storage{
+  constructor(payload, account){
+    super(payload.config, account)
+
+    this.value = payload.value;
+    this.type = 'class'
+  }
+
+  initiate = async({chain, class_chain, ass_chain})=>{
+    let config = this.value
+    let conf = this.config.content;
+    let vm = this.account.vm;
+
+    let obj = {__classifier__: config.identifier, __class_config__: this.config.path}
+
+    let storage_chain = await chain.chain(config.location)
+    let addr = await storage_chain.write(obj)
+
+    class_chain = await storage_chain.chain(config.identifier)
+    let ths = {object: addr, type: 'instance'}
+    await class_chain.write(ths)
+    console.log(obj, config)
+    
+    if (conf.methods.__init__){
+      console.log(conf.methods)
+
+      await vm.execute({
+        type:'call',
+        identifier: `${config.identifier}/__init__`,
+        arguments: config.arguments,
+        object: addr,
+      }, {chain, ass_chain})
+
+    }
+    return ths
+  }
+}
+
+export default Cls

package/Datatypes/conf.js

@@ -0,0 +1,117 @@
+import Arr from "./arr";
+import Storage from "./functions/storage";
+
+class Conf extends Storage{
+  constructor(object, account){
+    super(object, account)
+
+    this.value = object
+    this.type = 'config'
+  }
+
+  persist = async()=>{
+    await this.manager.oracle.fs.write(`${this.value.path}/.config`, JSON.stringify(this.value))
+  }
+
+  set_next = async(addr)=>{
+    this.value.next = addr;
+
+    await this.persist()
+  }
+
+  history = async(query)=>{
+    let res = []
+    let arr, pure;
+    if (typeof query === 'number'){
+      if(query >= 0){}
+      else{
+        arr= []
+        let x=query
+        while (x < 0){
+          arr.push(x)
+          x++
+        }
+      }
+    }
+
+    let i = 0;
+    let age = this.value.age;
+    
+    while(i < arr.length){
+      let timestep = arr[i], my_age;
+      if (timestep < 0){
+        my_age = age + timestep + 1
+      }else {
+        my_age = timestep;
+      }
+      if (my_age > age)continue;
+
+      let config = await this.manager.oracle.fs.get_config(this.value.path, null, {age: my_age})
+
+      res.push(pure?config: await config.read())
+      i++
+    }
+
+    return new Arr({value:res}, this.manager)
+  }
+
+  read = async()=>{
+    let current = this.value.current;
+    if (!current)return
+
+    return await this.manager.oracle.fs.read_file(current)
+  }
+
+  set_previous = async(addr)=>{
+    this.value.previous = addr;
+
+    await this.persist()
+  }
+
+  push = async(parent)=>{
+    this.value.lapse++
+
+    await this.persist()
+  }
+
+  link = async(addr)=>{
+    if (!addr )return;
+    
+    console.log(this.value, addr)
+    if (this.value.current){
+      let conf = await this.manager.oracle.fs.get_config(this.value.current)
+      await conf.set_next(addr)
+
+      let addr_conf = await this.manager.oracle.fs.get_config(`${addr}`)
+
+      await addr_conf.set_previous(this.value.current)
+    }
+
+    this.value.age++
+    this.value.current = addr;
+    await this.persist()
+  }
+}
+
+export default Conf
+
+// test = [1,2,3]
+// ./test
+// ./0 
+//  ./num1 {content:1, previous: null}
+//  ./config {recent: './num1'}
+// ./1
+//  ./num2 {content:2, previous: null}
+//  ./config {recent: './num2'}
+// ./2
+//  ./num3 {content:3, previous:.null}
+//  ./config {recent: './num3'}
+
+// ./.config 
+//    {type:'array', recent: './2'}
+
+// test[1] = 4
+//  ./1
+//    ./num4 {content:4, previous: './num2'}
+//    ./config {recent: './num4'}
+//  

package/Datatypes/func.js

@@ -1,18 +1,22 @@
-import Storage from './objects/storage'
+import Datatypes from "godprotocol/Objects/Datatypes";
 
-class Func extends Storage{
-  constructor(object){
+class Func extends Datatypes{
+  constructor(payload, account){
     super()
 
-    this.object = object
+    this.account = account
+    this.value = payload;
+    this.type = 'function'
   }
 
   literal = ()=>{
-    let obj = {...this.object}
-    delete obj.sequence
+    return `[${this.value.value || this.value.name}]`
+  }
 
-    return obj
+  sync = async()=>{
+    return this
   }
 }
 
+
 export default Func

package/Datatypes/functions/storage.js

@@ -0,0 +1,24 @@
+class Storage {
+  constructor(manager) {
+    this.manager = manager
+    this.oracle = this.manager.oracle
+  }
+
+  sync = async(manager)=>{
+    if (!this.manager){
+      this.manager = manager
+      this.oracle = this.manager.oracle
+    }
+    return this;
+  }
+
+  persist =async (content, options={})=>{
+    return await this.oracle.write(this.path, content, options)
+  }
+
+  retrieve = async (options)=>{
+    return await this.oracle.read(this.path, options)
+  }
+}
+
+export default Storage;