godprotocol 1.1.32 → 1.2.0

package/Datatypes/instance.js

@@ -1,150 +1,115 @@
-import Datatypes from "godprotocol/Objects/Datatypes";
+import Storage from "godprotocol/Datatypes/functions/storage.js";
 
-class Instance extends Datatypes{
-  constructor(payload, account){
-    super()
+class Instance extends Storage{
+  constructor(config, account){
+    super(account)
 
-    this.account = account
-    this.value = payload;
+    this.config = config;
     this.type = 'instance'
-  }
-
-  operate = async(op, args, options={})=>{
-    let {classifier} = options;
-    let value;
-    switch(classifier){
-      case 'twain':
-        value = await this.twain(op, args, options)
-        break;
-      case 'number':
-        value = await this.number(op, args)
-        break;
-      case 'array':
-        value = await this.array(op, args, options)
-        break;
-      case 'string':
-        value = await this.string(op, args)
-        break;
-    }
 
-    return value;
+    this.lits = ['listen', 'emit']
   }
 
-  set = async(last, value)=>{
-    let prop = await last.literal()
-    let oracle = this.account.manager.oracle
-    let hsh = await oracle.hash(prop)
-
-    let {content, path} = this.value
+  get_cls_fold = async()=>{
+    let cls = await this.account.manager.gds.folder(this.config.classifier)
+    return cls;
+  }
 
-    let prop_path = `${path}/${hsh}`
-    await oracle.fs.mkdir(prop_path)
-    let prop_conf = await oracle.fs.read(`${prop_path}/.config`)
-    if (!prop_conf) prop_conf = {index: -1}
+  run = async(call_config, options={})=>{
+    let {thread} = options;
+    let {identifier, arguments: args} = call_config;
+    let {value, _id} = identifier;
     
-    if (value.type !== 'address'){
-      value = {type: 'address', value: value.value.path}
-    }
-    await oracle.fs.write(`${prop_path}/${prop_conf.index + 1}`, JSON.stringify([last.value.path, value.value]))
-    prop_conf.index += 1
-    await oracle.fs.write(`${prop_path}/.config`, JSON.stringify(prop_conf))
-    content[hsh] = prop_conf.index
+    let func = await this.account.vm.cloth({
+      type: 'function',
+      address: value,
+      _id
+    })
+    await func.invoke([...args], {
+      thread, 
+      instance_: {
+        type: 'address',
+        value: this.config.location,
+        _id: this.config._id
+      }
+    })
+  } 
 
-    let path_conf = await oracle.fs.read(`${path}/.config`)
+  invoke = async(args, options)=>{
+    let cll = await this.get_('__call__')
+    let {vm} = this.account
+    if (!cll) return await vm.throw_error({type:"TypeError", message:`${this.config.name} Instance has no __call__ operator`})
     
-    let n_hash = await oracle.hash(content)
-    await oracle.fs.write(`${path}/${n_hash}`, JSON.stringify({content, type: 'instance', previous: `${path}/${path_conf.current}`}))
-    path_conf.current = n_hash;
-    await oracle.fs.write(`${path}/.config`, JSON.stringify(path_conf))
+    let {chain} = options;
+    return await vm.execute_call({
+      type: 'call',
+      identifier: cll,
+      arguments: args,
+      location: vm.gen_location()
+    }, {chain})
   }
 
-  get = async (prop, options={})=>{
-    let oracle = this.account.manager.oracle
-    let hsh = await oracle.hash(prop)
-    let {config, chain} = options;
-    let {content, path} = this.value, result;
+  literal = async (options={})=>{
+    let {raw, no_lit} = options
     
-    let classifier = await oracle.hash('__classifier__')
-    let pair = await oracle.fs.read(`${path}/${classifier}/${content[classifier]}`);
-    let val = await oracle.fs.read(pair[1])
-
-    let is_datatype = this.account.vm.datatypes.includes(val)
+    let chain = await this.chain(), 
+      print = await this.get_('__print__', true), result;
 
-    if(Object.keys(content).includes(hsh)){
-      result = await oracle.fs.read(`${path}/${hsh}/${content[hsh]}`)
-      
-      if (result){
-        let res = await oracle.fs.read(result[1])
-        if(!res) result = {type: 'address', value: result[1]}
-        else result = res
-      }
-      
+    if (print){
+      console.log(print, 'uh')
     }else {
-      if (is_datatype){
-        let res = {
-          type:'address',
-          value: prop,
-          object: path
-        }
-        if(val === 'array' && typeof prop === 'number' && options.obj){
-          result = await this.operate('index', [options.obj], {classifier: val})
-        }else if (val === 'twain'){
-          if (!this.is_literal && options.obj){
-            result = await this.operate('get', [options.obj], {classifier: val})
-            result= await this.account.vm.operate_result(result, config, chain)
-          }else result = res
-        } else result = res
-      }
-
+      result = `[Instance ${this.config.name}]`
     }
-    
-    return result;    
+    return result
   }
 
-  literal = async ()=>{
-    let oracle = this.account.manager.oracle;
-    if (!this.lit){
-      this.lit = {}
-      let {content, path} = this.value;
+  set_ = async(prop, value)=>{
+    let {vm, manager} = this.account
+    let propobj = await vm.cloth(prop)
+    let valobj = await vm.cloth(value)
 
-      for (let hsh in content){
-        let value = content[hsh];
+    let prop_lit = await propobj.literal()
 
-        let addr = `${path}/${hsh}`;
-        let pair = await oracle.fs.read(`${addr}/${value}`);
-        let prop = await oracle.fs.read(pair[0])
-        let val = await oracle.fs.read(pair[1])
+    if (['function', 'class'].includes(valobj.type)){
+      this.config.methods[prop_lit] = valobj.ref()
+      delete this.config.properties[prop_lit]
+    }else {
+      this.config.properties[prop_lit] = valobj.ref()
+      delete this.config.methods[prop_lit]
+    }
+    await (await manager.ds.folder(this.config.location)).write(this.config, {replace: true})
+  }
 
-        this.lit[prop] = val
-      }
+  get_ = async(prop, raw)=>{
+    let res = this.config.properties[prop], is_method;
+    if (!res){
+      res = this.config.methods[prop]
+      is_method = true  
     }
-    
-    if (this.lit.__classifier__ === 'twain'){
-      let vm = this.account.vm;
-      if(!this.lit.content_addr) this.lit.content_addr = {...this.lit.content}
-      
-      for (let p in this.lit.content_addr){
-        let [prop, value] = this.lit.content_addr[p]
-        prop = await vm.cloth_content(await vm.resolve_address(prop))
-        value = await vm.cloth_content(await vm.resolve_address(value))
-        
-        delete this.lit.content[p] 
-        this.lit.content[await prop.literal()] = await value.literal()
-      }
-    }else if (this.lit.__classifier__ === 'array'){
-      let vm = this.account.vm;
+
+    if (!res){
+      if (this.methods[prop]){
+        res = {
+          type: 'address',
+          value: prop,
+          _id: prop.repeat(2),
+          object: this.ref(),
+        }
+        return res;
+      } else return !raw && await this.account.vm.voided()
+    }else{
       
-      if(!this.lit.content_addr)
-      this.lit.content_addr = [...this.lit.content]
-      for (let i=0; i< this.lit.content_addr.length; i++){
-        let item = this.lit.content_addr[i]
-        item = await vm.cloth_content(await vm.resolve_address(item))
-        
-        this.lit.content[i] = await item.literal()
-      }
+    }
 
+    res = res.split('/')
+    res = {
+      type: 'address',
+      value: res.slice(0,-1).join('/'),
+      _id: res.slice(-1)[0],
     }
-    return this.lit.content;
+    if (is_method) res.object = this.ref()
+
+    return res;
   }
 
   sync = async()=>{

package/Datatypes/num.js

@@ -1,169 +1,208 @@
-import Storage from "./functions/storage";
+import Storage from "./functions/storage.js";
 
 class Num extends Storage {
-  constructor(config, manager) {
-    super(manager)
+  constructor(config, account) {
+    super(account)
 
     this.config = config
     this.type = 'number'
+
+    this.methods = {
+      ...this.methods,
+      'inc': {args: [['other', 'number']], ret: ['result', 'number']},
+      'dec': {args: [['other', 'number']], ret: ['result', 'number']},
+      '__mod_': {args: [['other', 'number']], ret: ['result', 'number']},
+      '__exp__': {args: [['other', 'number']], ret: ['result', 'number']},
+      '__floordiv__': {args: [['other', 'number']], ret: ['result', 'number']},
+      
+      'to_degrees': {args: [], ret: ['result', 'number']},
+      'to_radians': {args: [], ret: ['result', 'number']},
+      'to_string': {args: [], ret: ['result', 'number']},
+      'to_float': {args: [], ret: ['result', 'number']},
+      'to_int': {args: [], ret: ['result', 'number']},
+      'sqrt': {args: [], ret: ['result', 'number']},
+      'abs': {args: [], ret: ['result', 'number']},
+      'sin': {args: [], ret: ['result', 'number']},
+      'tan': {args: [], ret: ['result', 'number']},
+      'cos': {args: [], ret: ['result', 'number']},
+      'asin': {args: [], ret: ['result', 'number']},
+      'acos': {args: [], ret: ['result', 'number']},
+      'atan': {args: [], ret: ['result', 'number']},
+      'atan2': {args: [], ret: ['result', 'number']},
+      'tanh': {args: [], ret: ['result', 'number']},
+      'sinh': {args: [], ret: ['result', 'number']},
+      'cosh': {args: [], ret: ['result', 'number']},
+      'acosh': {args: [], ret: ['result', 'number']},
+      'asinh': {args: [], ret: ['result', 'number']},
+      'atanh': {args: [], ret: ['result', 'number']},
+      
+      'floor': {args: [], ret: ['result', 'number']},
+      'ceil': {args: [], ret: ['result', 'number']},
+      'round': {args: [['other', 'number']], ret: ['result', 'number']},
+      
+      'is_prime': {args: [], ret: ['result', 'boolean']},
+      'is_perfect_square': {args: [], ret: ['result', 'boolean']},
+      'log': {args: [['other', 'number']], ret: ['result', 'number']},
+      'is_even': {args: [], ret: ['result', 'boolean']},
+      'is_odd': {args: [], ret: ['result', 'boolean']},
+      'factorial': {args: [['factor', 'number']], ret: ['result', 'number']},
+    }
+  }
+
+  __or__ = other=>this.value || other
+  
+  __and__ = other=>this.value && other
+
+  __add__ = (other)=>{
+    return this.value + other
+  }
+
+  inc = async(other)=>{
+    other = other || 1
+    let val = this.value + other;
+    let {vm, chain} = this.account
+
+    return await vm.instantiate({
+      type: 'number',
+      value: val.toString(),
+      location: this.address
+    }, {chain, _id: this.config._id})
+  }
+
+  dec = async(other)=>{
+    other = other || 1
+    let val = this.value - other;
+    let {vm, chain} = this.account
+
+    return await vm.instantiate({
+      type: 'number',
+      value: val.toString(),
+      location: this.address
+    }, {chain, _id: this.config._id})
+  }
+
+  __mul__ = (other)=>{
+    return this.value * other
+  }
+
+  __sub__ = (other)=>{
+    return this.value - other
+  }
+
+  __div__ = async (other)=>{
+    if(other === 0){
+      return await this.account.vm.throw_error({type:"ZeroDivisionError", message: "Cannot have 0 be a denominator"})
+    }else 
+    return this.value / other
+  }
+
+  __gt__ = (other)=> this.value >  other
+  __lt__ = (other)=> this.value <  other
+  __gte__ = (other)=> this.value >=  other
+  __lte__ = (other)=> this.value <=  other
+  __ne__ = (other)=> this.value !=  other
+  __eq__ = (other)=> this.value ==  other
+  __mod__ = (other)=> this.value %  other
+  __exp__ = (other)=> this.value **  other
+  __floordiv__ = (other)=> Math.floor(this.value /  other)
+  
+  to_degrees = ()=>{
+    return this.value * (180 / Math.PI)
+  }
+
+  to_radians = ()=>{
+    return this.value * (Math.PI / 180)
+  }
+
+  to_string = ()=>{
+    return this.value.toString()
+  }
+
+  to_float = (other)=>{
+    return this.value.toFixed(other)
+  }
+
+  to_int = ()=>parseInt(this.value)
+
+  sqrt = ()=>Math.sqrt(this.value)
+
+  abs = ()=>Math.abs(this.value)
+
+  sin = ()=>Math.sin(this.value)
+  tan = ()=>Math.tan(this.value)
+  cos = ()=>Math.cos(this.value)
+  asin = ()=>Math.asin(this.value)
+  acos = ()=>Math.acos(this.value)
+  atan = ()=>Math.atan(this.value)
+  atan2 = ()=>Math.atan2(this.value)
+  tanh = ()=>Math.tanh(this.value)
+  sinh = ()=>Math.sinh(this.value)
+  cosh = ()=>Math.cosh(this.value)
+  asinh = ()=>Math.asinh(this.value)
+  acosh = ()=>Math.acosh(this.value)
+  atanh = ()=>Math.atanh(this.value)
+
+  floor = ()=>Math.floor(this.value)
+  
+  ceil = ()=>Math.ceil(this.value)
+
+  round = (other)=>{
+    let result;
+    if (other) {
+      result = Number(Number(this.value).toFixed(other));
+    } else result = Math.round(this.value);
+
+    return result;
   }
 
-  call = async (name, args)=>{
-    let result, other, me = await this.literal();
-
-    other = args[0] && await args[0].literal()
-    switch(name){
-      case '__add__':
-        result = me + other;
-        break;
-      case '__sub__':
-        result = me - other;
-        break;
-      case '__mul__':
-        result = me * other;
-        break;
-      case '__div__':
-        result = me / other;
-        break;
-      case '__exp__':
-        result = me ** other;
-        break;
-      case '__floordiv__':
-        result = Math.floor(me / other);
-        break;
-      case '__mod__':
-        result = me % other;
-        break;
-      case '__eq__':
-        result = me === other
-        break;
-      case '__ne__':
-        result = me !== other
-        break;
-      case '__lt__':
-        result = me < other
-        break;
-      case '__lte__':
-        result = me <= other
-        break;
-      case '__gt__':
-        result = me > other
-        break;
-      case '__gte__':
-        result = me >= other
-        break;
-      case 'abs':
-        result = Math.abs(me)
-        break;
-      case 'sqrt':
-        result = Math.sqrt(me)
-        break;
-      case 'to_int':
-        result = parseInt(me)
-        break;
-      case 'to_float':
-        result = Number(me).toFixed(other)
-        break;
-      case 'to_string':
-        result = me.toString()
-        break;
-      case 'tan':
-        result = Math.tan(me)
-        break;
-      case 'sin':
-        result = Math.sin(me)
-        break;
-      case 'cos':
-        result = Math.cos(me)
-        break;
-      case 'atan':
-        result = Math.atan(me)
-        break;
-      case 'atan2':
-        result = Math.atan2(me)
-        break;
-      case 'asin':
-        result = Math.asin(me)
-        break;
-      case 'acos':
-        result = Math.acos(me)
-        break;
-      case 'tanh':
-        result = Math.tanh(me)
-        break;
-      case 'sinh':
-        result = Math.sinh(me)
-        break;
-      case 'cosh':
-        result = Math.cosh(me)
-        break;
-      case 'asinh':
-        result = Math.asinh(me)
-        break;
-      case 'acosh':
-        result = Math.acosh(me)
-        break;
-      case 'atanh':
-        result = Math.atanh(me)
-        break;
-      case 'round':
-        if (other){
-          result = Number(Number(me).toFixed(other))
-        }else result = Math.round(me)
-        break;
-      case 'ceil':
-        result = Math.ceil(me)
-        break;
-      case 'floor':
-        result = Math.floor(me)
-        break;
-      case 'is_prime':
-        if (me <= 1) result = false;
-        if (me <= 3) result = true;
-        
-        if (me % 2 === 0 || me % 3 === 0) result = false; 
-        
-        for (let i = 5; i * i <= me; i += 6) {
-          if (me % i === 0 || me % (i + 2) === 0) {
-            result = false;
-          }
-        }
-        result = true;
-        break;
-      case 'is_odd':
-        result = (me % 2) === 1
-        break
-      case 'is_even':
-        result = (me % 2) === 0
-        break
-      case 'log':
-        if (!other || (other === 10))
-          result = Math.log10(me)
-        else if (other === Math.E){
-          result = Math.log(me)
-        }else result = Math.log(me) / Math.log(other)
-        break;
-      case 'factorial':
-        result = this.factorial(me)
-        break;
-      case 'is_perfect_square':
-        if (me < 0) result = false; 
-        
-        let sqrt = Math.sqrt(me);
-        result = sqrt === Math.floor(sqrt);
-        break
-      case 'to_degrees':
-        result = me * (180 / Math.PI)
-        break;
-      case 'to_radians':
-        result = me * (Math.PI / 180)
-        break;
+  is_prime = ()=>{
+    let result = true;
+    if (this.value <= 1) result = false;
+    if (this.value <= 3) result = true;
+
+    if (this.value % 2 === 0 || this.value % 3 === 0) result = false;
+
+    for (let i = 5; i * i <= this.value; i += 6) {
+      if (this.value % i === 0 || this.value % (i + 2) === 0) {
+        result = false;
+      }
     }
+    
+    return result;
+  }
+
+  is_perfect_square = ()=>{
+    let result;
+    if (this.value < 0) result = false;
+
+    let sqrt = Math.sqrt(this.value);
+    result = sqrt === Math.floor(sqrt);
 
     return result;
   }
 
+  log = (other)=>{
+    let result;
+    if (!other || other === 10) result = Math.log10(this.value);
+    else if (other === Math.E) {
+      result = Math.log(this.value);
+    } else result = Math.log(this.value) / Math.log(other);
+
+    return result
+  }
+
+  is_even = ()=>{
+    return this.value % 2 === 0
+  }
+
+  is_odd = ()=>!this.is_even()
+
+  literal = async()=>{
+    return Number(this.config.value)
+  }
+
   factorial = (value)=>{
+    if (value == null) value = this.value;
     if (value === 0)
       return 1
     return value * this.factorial(value - 1)