godprotocol 1.1.0 → 1.1.1

package/Datatypes/arr.js

@@ -0,0 +1,30 @@
+import Storage from 'godprotocol/Datatypes/objects/storage'
+
+const arr = (args, vm, options)=>{
+  let {value} = args;
+
+ Storage.cold_store(value, vm, options)
+}
+
+
+class Arr extends Storage{
+  constructor(value, vm){
+    super()
+    
+    this.value = value
+    this.vm = vm
+  }
+
+  literal = ()=>{
+    return this.value.map(val=>{
+      return this.vm.account.cloth_object(this.vm.read_chain(val)).literal()
+    })
+  }
+
+  store = (options)=>{
+    Storage.cold_store(this.value, this.vm, options)
+  }
+}
+
+export default Arr
+export {arr}

package/Datatypes/bool.js

@@ -0,0 +1,25 @@
+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)
+}
+
+class Bool extends Storage {
+  constructor(value, vm){
+    super()
+
+    this.value = value;
+    this.vm = vm
+  }
+
+}
+
+export default Bool
+export {bool}

package/Datatypes/func.js

@@ -0,0 +1,18 @@
+import Storage from './objects/storage'
+
+class Func extends Storage{
+  constructor(object){
+    super()
+
+    this.object = object
+  }
+
+  literal = ()=>{
+    let obj = {...this.object}
+    delete obj.sequence
+
+    return obj
+  }
+}
+
+export default Func

package/Datatypes/instance.js

@@ -0,0 +1,33 @@
+import Storage from './objects/storage'
+
+class Instance extends Storage{
+  constructor(object, vm){
+    super()
+
+    this.object = object;
+    this.vm = vm;
+  }
+
+  add_prop = (name, real_address)=>{
+    if(!this.object.namespace){
+      this.object.namespace = {}
+    }
+    this.object.namespace[name] = real_address
+  }
+
+  get_prop = identifier =>{
+    return this.object.namespace[identifier]
+  }
+
+  store = (options)=>{
+    this.object.type = 'instance'
+
+    this.vm.write_chain(this.object, this.object.real_address || options.location)
+  }
+
+  stringify = ()=>{
+    return this.object
+  }
+}
+
+export default Instance

package/Datatypes/num.js

@@ -0,0 +1,22 @@
+import Storage from 'godprotocol/Datatypes/objects/storage'
+
+const num = (args, vm, options)=>{
+  let {value} = args;
+  
+  let obj = new Num(value, vm)
+  obj.store()
+
+  vm.air_object(obj, options)
+}
+
+class Num extends Storage {
+  constructor(value, vm){
+    super()
+
+    this.value = value;
+    this.vm = vm
+  }
+}
+
+export default Num
+export {num}

package/Datatypes/objects/operations.js

@@ -0,0 +1,75 @@
+class Operations {
+  constructor(){}
+
+  operation = (op, other) => {
+    let res;
+    
+    switch(op){
+      case "add":
+        res = this.value + other.value
+        break
+      ;
+      case "multiply":
+        if (Array.isArray(this.value)){
+          if(typeof other.value !== 'number') res = null
+          else {
+            res = []
+            for (let i=0; i< other.value; i++){
+              res.push(...this.value)
+            }
+          }
+        }else {
+          if (typeof this.value === 'string' && typeof other.value === 'number'){
+            res = this.value.repeat(other.value)
+          }else res = this.value * other.value
+        }
+        
+        break
+      ; 
+      case "divide":
+        res = this.value / other.value
+        break
+      ; 
+      case "subtract":
+        res = this.value - other.value
+        break
+      ; 
+      case "equal":
+        res = this.value === other.value
+        break
+      ; 
+      case "not_equal":
+        res = this.value !== other.value
+        break
+      ; 
+      case "lt":
+        res = this.value < other.value
+        break
+      ; 
+      case "gt":
+        res = this.value > other.value
+        break
+      ; 
+      case "lte":
+        res = this.value <= other.value
+        break
+      ; 
+      case "gte":
+        res = this.value >= other.value
+        break
+      ; 
+      case "mod":
+        res = this.value % other.value
+        break
+      ; 
+      case "exp":
+        res = this.value ** other.value
+        break
+      ; 
+    }
+
+    return res
+  }
+}
+
+export default Operations

package/Datatypes/objects/storage.js

@@ -0,0 +1,293 @@
+import { generate_random_string } from "generalised-datastore/utils/functions";
+import Operations from "./operations";
+
+class Storage extends Operations {
+  constructor() {
+    super();
+
+    this._id = generate_random_string(14, "alnum");
+  }
+
+  static props = (type, prop) => {
+    let { case_ } = require("./../../Executables/functions/methods/string");
+
+    let type_props = {
+      array: {
+        pop: {},
+        push: {},
+        insert: {},
+        repeat: {},
+        map: {},
+        extend: {},
+        index: {},
+        find: {},
+        join: {},
+        findindex: {},
+        clear: {},
+        slice: { alias: "arr_slice" },
+        length: { property: true },
+        splice: {},
+        filter: {},
+        copy: {},
+        deepcopy: {},
+      },
+      number: {
+        add: {alias:"__add__"},
+        sub: {alias: '__subtract__'},
+        mul: {alias:"__multiply__"},
+        div: {alias:"__divide__"},
+        exp: {alias:"__exp__"},
+        mod: {alias:"__mod__"},
+        abs: {
+          property: true,
+          callable: (num)=>Math.abs(num)
+        },
+        sqrt: {
+          property: true,
+          callable: (num)=>Math.sqrt(num)
+        },
+        acos: {
+          property: true,
+          callable: (num)=>Math.acos(num)
+        },
+        asin: {
+          property: true,
+          callable: (num)=>Math.asin(num)
+        },
+        atan: {
+          property: true,
+          callable: (num)=>Math.atan(num)
+        },
+        atan2: {
+          property: true,
+          callable: (num)=>Math.atan2(num)
+        },
+        acosh: {
+          property: true,
+          callable: (num)=>Math.acosh(num)
+        },
+        asinh: {
+          property: true,
+          callable: (num)=>Math.asinh(num)
+        },
+        atanh: {
+          property: true,
+          callable: (num)=>Math.atanh(num)
+        },
+        trunc: {
+          property: true,
+          callable: (num)=>Math.trunc(num)
+        },
+        round: {
+          property: true,
+          callable: (num)=>Math.round(num)
+        },
+        ceil: {
+          property: true,
+          callable: (num)=>Math.ceil(num)
+        },
+        floor: {
+          property: true,
+          callable: (num)=>Math.floor(num)
+        },
+        random: {
+          property: true,
+          callable: (num)=>Math.random(num)
+        },
+        log: {
+          property: true,
+          callable: (num)=>Math.log(num)
+        },
+        log1p: {
+          property: true,
+          callable: (num)=>Math.log1p(num)
+        },
+        log10: {
+          property: true,
+          callable: (num)=>Math.log10(num)
+        },
+        sin: {
+          property: true,
+          callable: (num)=>Math.sin(num)
+        },
+        tan: {
+          property: true,
+          callable: (num)=>Math.tan(num)
+        },
+        cos: {
+          property: true,
+          callable: (num)=>Math.cos(num)
+        },
+        sin: {
+          property: true,
+          callable: (num)=>Math.sin(num)
+        },
+        sign: {
+          property: true,
+          callable: (num)=>Math.sign(num)
+        }
+      },
+      twain: {
+        set: { alias: "twain_set" },
+        get: { alias: "twain_get" },
+        unset: {},
+        entries: {},
+        keys: {},
+      },
+      string: {
+        slice: {},
+        trim: {},
+        split: {},
+        trimstart: {},
+        trimend: {},
+        repeat: { alias: "str_repeat" },
+        includes: {},
+        length: { property: true },
+        index: { alias: "string_index" },
+        indexof: {},
+        concat: {},
+        upper: {
+          property: true,
+          callable: (args, vm, options) =>
+            case_(args, vm, { ...options, type: 0 }),
+        },
+        lower: {
+          property: true,
+          callable: (args, vm, options) =>
+            case_(args, vm, { ...options, type: 1 }),
+        },
+        title: {
+          property: true,
+          callable: (args, vm, options) =>
+            case_(args, vm, { ...options, type: 2 }),
+        },
+      },
+    };
+
+    return type_props[type][prop];
+  };
+
+  static get_prop = (classifier, prop) => {
+    let {
+      entries,
+      keys,
+    } = require("./../../Executables/functions/methods/twain");
+
+    let class_props = {
+      twain: {
+        entries: {
+          property: true,
+          callable: entries,
+        },
+        keys: {
+          property: true,
+          callable: keys,
+        },
+        values: {
+          property: true,
+          callable: (args, vm, options) =>
+            keys(args, vm, { ...options, values: true }),
+        },
+        default_value: {},
+        unset: {},
+        set: { alias: "twain_set" },
+        clear: { alias: "twain_clear" },
+        get: { alias: "twain_get" },
+      },
+    };
+
+    return class_props[classifier][prop];
+  };
+
+  static cold_store = (value, vm, options) => {
+    let _id = generate_random_string(14, "alnum"),
+      type;
+
+    if (Array.isArray(value)) {
+      value = value.map((val) => vm.read_chain(val).real_address);
+      type = "array";
+    } else {
+      for (let v in value) {
+        let val = value[v];
+        val[0] = vm.read_chain(val[0]).real_address;
+        val[1] = vm.read_chain(val[1]).real_address;
+      }
+      type = "twain";
+    }
+
+    let real_addr = `${vm.resolve_addr(options.location)}/${_id}`;
+
+    let static_address = vm.account.save(value)
+    let addr = vm.account.save({
+      static_address,
+      _id,
+      type,
+      real_address: real_addr,
+    });
+    vm.handle_chain(real_addr).forge_block({ metadata: { output: addr } });
+    vm.handle_chain(options.location)
+      .clear_config()
+      .forge_block({ metadata: { output: addr } });
+  };
+
+  cascade = ({location})=>{
+    location = this.vm.resolve_addr(location)
+    if (Array.isArray(this.value)){
+      for (let v =0; v< this.value.length; v++){
+        let item = this.value[v]
+
+        let val = this.vm.air_object(item, {cascade:true, location})
+        this.value[v] = `${location}/${val._id}`
+      }
+    }else {
+      let {
+        hash_for_twain
+      } = require("./../../Executables/functions/methods/twain");
+
+      let obj = {}
+      for (let p in this.value){
+        let prop = this.vm.air_object(p, {cascade:true, location})
+        let value = this.vm.air_object(this.value[p], {cascade:true, location})
+
+        obj[hash_for_twain(p, this.vm)] = [`${location}/${prop._id}`, `${location}/${value._id}`]
+      }
+      this.value = obj;
+    }
+  }
+
+  store = () => {
+    this.static_address = this.vm.account.save(this.value);
+
+    return this.static_address;
+  };
+
+  literal = () => {
+    return this.value || this.object;
+  };
+
+  assume_metadata = (metadata) => {
+    this._id = metadata._id;
+    this.address = this.vm.resolve_addr(metadata.address);
+    this.static_address = metadata.static_address;
+  };
+
+  stringify = (address) => {
+    let type = typeof this.value;
+    return {
+      static_address: this.static_address,
+      _id: this._id,
+      address,
+      real_address: `${this.vm.resolve_addr(address)}/${this._id}`,
+      type:
+        type === "object"
+          ? Array.isArray(this.value)
+            ? "array"
+            : this.value
+            ? "twain"
+            : "void"
+          : type,
+    };
+  };
+}
+
+export default Storage;

package/Datatypes/register.js

@@ -0,0 +1,66 @@
+import {num} from './num'
+import {str} from './str'
+import {arr} from './arr'
+import {twa} from './twa'
+import {bool} from './bool'
+import {voi} from './voi'
+
+const datatypes_register = (account)=>{
+  let add_callable = account.vm.add_callable;
+
+  add_callable('number', {
+    callable: num,
+    config:{
+      parameters: [
+        {name:'value', position:0}
+      ]
+    }
+  })
+
+  add_callable('string', {
+    callable: str,
+    config:{
+      parameters: [
+        {name:'value', position:0}
+      ]
+    }
+  })
+
+  add_callable('array', {
+    callable: arr,
+    config:{
+      parameters: [
+        {name:'value', position:0}
+      ]
+    }
+  })
+
+  add_callable('twain', {
+    callable: twa,
+    config:{
+      parameters: [
+        {name:'value', position:0}
+      ]
+    }
+  })
+
+  add_callable('boolean', {
+    callable: bool,
+    config:{
+      parameters: [
+        {name:'value', position:0}
+      ]
+    }
+  })
+
+  add_callable('void', {
+    callable: voi,
+    config:{
+      parameters: [
+        {name:'value', position:0}
+      ]
+    }
+  })
+}
+
+export default datatypes_register

package/Datatypes/str.js

@@ -0,0 +1,23 @@
+import Storage from 'godprotocol/Datatypes/objects/storage'
+
+const str = (args, vm, options)=>{
+  let {value} = args;
+
+  
+  let obj = new Str(value, vm)
+  obj.store()
+
+  vm.air_object(obj, options)
+}
+
+class Str extends Storage {
+  constructor(value, vm){
+    super()
+
+    this.value = value;
+    this.vm = vm
+  }
+}
+
+export default Str
+export {str}

package/Datatypes/twa.js

@@ -0,0 +1,30 @@
+import Storage from './objects/storage'
+
+const twa = (args, vm, options)=>{
+  let {value} = args;
+
+  Storage.cold_store(value, vm, options)
+}
+
+class Twa extends Storage {
+  constructor(value, vm){
+    super()
+
+    this.value = value;
+    this.actual_static = value
+    this.vm = vm
+  }
+
+  literal = ()=>{
+    let lit = {}
+    for (let v in this.value){
+      let [prop, val] = this.value[v]
+      
+      lit[this.vm.account.cloth_object(this.vm.read_chain(prop)).literal()] = this.vm.account.cloth_object(this.vm.read_chain(val)).literal()
+    }
+    return lit
+  }
+}
+
+export default Twa
+export {twa}

package/Datatypes/voi.js

@@ -0,0 +1,23 @@
+import Storage from 'godprotocol/Datatypes/objects/storage'
+
+const voi = (args, vm, options)=>{
+  let {value} = args;
+
+  
+  let obj = new Voi(value, vm)
+  obj.store()
+
+  vm.air_object(obj, options)
+}
+
+class Voi extends Storage {
+  constructor(value, vm){
+    super()
+
+    this.value = value;
+    this.vm = vm
+  }
+}
+
+export default Voi
+export {voi}