godprotocol 1.1.32 → 1.2.1

package/Datatypes/bool.js

@@ -1,13 +1,16 @@
-import Storage from "./functions/storage";
+import Storage from "./functions/storage.js";
 
 class Bool extends Storage {
-  constructor(payload, account) {
-    super(payload.config, account);
+  constructor(config, account) {
+    super(config, account);
 
-    this.instance_object = payload.value;
-    this.value = JSON.parse(payload.value.value)
+    this.config = config
     this.type = 'boolean'
   }
+
+  literal = ()=>{
+    return JSON.parse(this.config.value)
+  }
 }
 
 export default Bool;

package/Datatypes/callable.js

@@ -1,4 +1,4 @@
-import Storage from "./functions/storage";
+import Storage from "./functions/storage.js";
 
 class Callable extends Storage {
   constructor(payload, account) {

package/Datatypes/cls.js

@@ -1,40 +1,209 @@
-import Storage from "./functions/storage";
+import { generate_random_string } from "generalised-datastore/utils/functions.js";
+import Storage from "godprotocol/Datatypes/functions/storage.js";
 
 class Cls extends Storage{
-  constructor(payload, account){
-    super(payload.config, account)
+  constructor(config, account){
+    super(account)
 
-    this.value = payload.value;
+    this.account = account
+    this.config = config;
     this.type = 'class'
+
+    this.lits = ['listen', 'emit']
+
+    this.methods = {
+      ...this.methods,
+      'get_instance': {args: [['query', 'twain']], ret: ['object', 'instance | void']}
+    }
   }
 
-  initiate = async({chain, class_chain, ass_chain})=>{
-    let config = this.value
-    let conf = this.config.content;
-    let vm = this.account.vm;
+  get_instance = async(query, is_obj)=>{
+    let account = this.account, res;
+
+    if (is_obj === true){
+      console.log(query)
+      res = query
+    } else {
+      let folder = await account.manager.ds.folder(`${this.config.address}/instances`, {account: account.physical_address})
+      res = await folder.readone(await query.literal())
+    }
+    
+    // console.log(query, folder.address)
+    if(!res){
+      return
+    
+    }
+
+    console.log(query)
+
+    let ponse = await (await account.manager.ds.folder(res.location)).write(res, {replace: true})
+    console.log(ponse)
 
-    let obj = {__classifier__: config.identifier, __class_config__: this.config.path}
+    for (let prop in res.properties){
+      let value = res.properties[prop]
+      let spli = account.vm._split_datapath(value)
+      let raw = await account.manager.ds.folder(spli[0], {account: account.physical_address})
+      raw = await raw.readone({_id: spli[1]})
+      
+      if (!raw) continue
 
-    let storage_chain = await chain.chain(config.location)
-    let addr = await storage_chain.write(obj)
+      // console.log(raw)
+      
+      if (raw.type === 'array'){
+        await (await account.vm.cloth_content(raw)).retrieve(raw.items)
+      } else if (raw.type === 'twain'){
+        await (await account.vm.cloth_content(raw)).retrieve(raw.entries)
+      } else {
+        await (await account.manager.ds.folder(raw.location)).write(raw, {replace: true}) 
+      }
+    }
+    return {
+      type: 'address',
+      _id: res._id,
+      value: res.location,
+    }
+  }
 
-    class_chain = await storage_chain.chain(config.identifier)
-    let ths = {object: addr, type: 'instance'}
-    await class_chain.write(ths)
-    console.log(obj, config)
+  get_ = async(name)=>{
     
-    if (conf.methods.__init__){
-      console.log(conf.methods)
+  }
+
+  run_init = async ({ins, args, vm, thread})=>{
+    let init = this.config.methods.__init__
 
-      await vm.execute({
-        type:'call',
-        identifier: `${config.identifier}/__init__`,
-        arguments: config.arguments,
-        object: addr,
-      }, {chain, ass_chain})
+    if (!init) return;
 
+    init = init.split('/')
+    let func = await vm.cloth({
+      type: 'function',
+      address: init.slice(0,-1).join('/'),
+      _id: init.slice(-1)[0]
+    })
+
+    await func.invoke([...args], {instance_:ins, thread})
+  }
+
+  handle_id = async(args)=>{
+    let _id, propaddr = this.config.class_.properties.__id_prop__, vm = this.account.vm
+    if (propaddr){
+      let spli = vm._split_datapath(propaddr)
+      let prop = await vm.cloth({
+        type: 'address',
+        value: spli[0],
+        _id: spli[1]
+      })
+      
+      let lit = await prop.literal()
+      
+      let arg = args.find(a=>a.identifier === lit)
+      let init = this.config.methods['__init__']
+      if (lit && init && !arg){
+        let spli = vm._split_datapath(init), indx;
+
+        init = await vm.cloth({address: spli[0], _id: spli[1], type: 'function'}, {just_content: true});
+        
+        for (let p=0; p < init.parameters.length; p++){
+          let param = init.parameters[p].split('/')
+          let name = param.slice(-3)[0]
+          
+          if(name === lit){
+            indx = p
+            break
+          }
+        }
+        arg = args[indx]
+      }
+      if (arg){
+        _id = await(await vm.cloth(arg)).literal()
+        _id = await vm.hash(_id)
+      }
     }
-    return ths
+    if (!_id)
+      _id = generate_random_string(16, 'alnum')
+
+    return _id;
+  }
+
+  invoke = async(args, options)=>{
+    let {thread, call_config} = options
+    
+    let _id = await this.handle_id(args);
+    let location = `${this.config.address}/instances`;
+
+    let folder = await this.account.manager.ds.folder(location)
+
+    let obj = {
+      type: 'instance',
+      name: this.config.name,
+      cls: this.config.address,
+      cls_id: this.config._id,
+      location,
+      _id,
+      properties: {},
+      methods: {},
+      inherited: []
+    }
+
+    let inherited = new Array(), lists = new Array(), benches = new Object(), {vm} = this.account;
+
+    await this.account.vm.base_classes(obj, this.config, {inherited, chain: this.account.chain, lists, benches})
+
+    await this.account.vm.spread_properties(obj, this.config, {lists, benches})
+
+    let init = this.config.methods.__init__
+    if (init){
+      let res = await folder.write(obj)
+      obj._id = res._id
+      obj.created = res.created
+
+      init = init.split('/')
+      let func = await vm.cloth({
+        type: 'function',
+        address: init.slice(0,-1).join('/'),
+        _id: init.slice(-1)[0]
+      })
+
+      await func.invoke([...args], {list: lists, instance_:{
+        type: 'address',
+        value: folder.address,
+        _id: obj._id
+      }})
+    }
+
+    let thread_id = await vm.account.manager.load(lists, vm.account, {
+      on_pointer: async (pointer, result)=>{
+        if (Object.values(benches).includes(pointer)){
+          for (let b in benches){
+            if (benches[b] === pointer){
+              obj.properties[b] = `${result.value}/${result._id}`
+
+              await folder.write(obj, {replace: true})
+              break
+            }
+          }
+        }
+      },
+      callback: async (result, thrd)=>{
+        let obj_addr = {
+          type:'address',
+          value: obj.location,
+          _id: obj._id
+        }
+        thread.results[thread.pointer-1] = obj_addr
+      },
+      spawn: thread._id,
+      pointer: thread.pointer
+    })
+    if (thread)
+      vm.envs[thread_id] = vm.envs[thread._id]
+  }
+
+  literal = (options={})=>{
+    return options.adm? this.config: `[${this.type} ${this.config.name}]`
+  }
+
+  sync = async()=>{
+    return this
   }
 }
 

package/Datatypes/conf.js

@@ -1,5 +1,5 @@
-import Arr from "./arr";
-import Storage from "./functions/storage";
+import Arr from "./arr.js";
+import Storage from "./functions/storage.js";
 
 class Conf extends Storage{
   constructor(object, account){

package/Datatypes/err.js

@@ -0,0 +1,25 @@
+import Storage from "godprotocol/Datatypes/functions/storage.js";
+
+class Err extends Storage{
+  constructor(config, account){
+    super(account)
+
+    this.account = account;
+    this.config = config
+    this.type = 'error'
+  }
+
+  get_type = async ()=>{
+    return this.config.value.type
+  }
+
+  get_message = async ()=>{
+    return this.config.value.message
+  }
+
+  literal = async()=>{
+    return `[Error ${this.config.value.type}]`
+  }
+}
+
+export default Err

package/Datatypes/func.js

@@ -1,22 +1,98 @@
-import Datatypes from "godprotocol/Objects/Datatypes";
+import { copy_object } from "generalised-datastore/utils/functions.js";
+import Storage from "godprotocol/Datatypes/functions/storage.js";
 
-class Func extends Datatypes{
-  constructor(payload, account){
-    super()
+class Func extends Storage {
+  constructor(config, account) {
+    super(account);
 
-    this.account = account
-    this.value = payload;
-    this.type = 'function'
+    this.config = config;
+    this.type = "function";
   }
 
-  literal = ()=>{
-    return `[${this.value.value || this.value.name}]`
+  invoke = async (args, options) => {
+    let {no_wait, list, thread, instance_, callback} = options || {}
+    let {vm} = this.account
+    let config = copy_object(this.config);
+    for (let p =0; p< config.parameters.length; p++){
+      config.parameters[p] = await vm.read_config(config.parameters[p])
+    }
+    
+    for (let a=0; a< args.length; a++){
+      let arg = args[a], param;
+
+      if (arg.identifier){
+        param = config.parameters.find(p=>p.identifier === arg.identifier)
+      }
+      if (!param){
+        param = config.parameters[a]
+        if (!param) {
+          continue;
+        }
+      }
+
+
+      param.value = {
+        type:'reference',
+        location: arg.value,
+        _id: arg._id
+      }
+      if (arg.object){
+        param.value.object = arg.object
+      }
+    }
+
+    if (instance_){
+      config.parameters.push({
+        type: 'assignment',
+        identifier: 'this',
+        value: {
+          type: 'reference',
+          location: instance_.value,
+          _id: instance_._id
+        }
+      })
+    }
+
+    let nodes = await this.account.vm.nodelist(config, {call: true, list})
+
+    if (list) return nodes
+
+    let thread_id = await vm.account.manager.load(nodes, vm.account, {
+      callback, 
+      spawn: no_wait ? null : thread._id, 
+      addr: this.config.address,
+      pointer: !no_wait && thread.pointer
+    })
+    if (thread){
+      vm.envs[thread_id] = vm.envs[thread._id]
+    }
+  };
+
+  set_ = async(prop, value)=>{
+    let prop_obj = await this.account.vm.cloth(prop)
+    let prop_val = await prop_obj.literal()
+
+    let addr = `${this.config.address}/${prop_val}`
+    let res = await (await this.account.manager.ds.folder(addr)).write(value, {replace: true})
+
+    return addr;
   }
 
-  sync = async()=>{
-    return this
+  get_ = async(prop)=>{
+    let res = await (await this.account.manager.ds.folder(`${this.config.address}/${prop}`)).readone()
+    
+    return res;
   }
-}
 
+  literal = (options = {}) => {
+    return options.adm
+      ? this.config
+      : `[${this.type} ${this.config.value || this.config.name}]`;
+  };
+
+  sync = async () => {
+    return this;
+  };
+}
 
-export default Func
+export default Func;