godprotocol/Objects/Datatypes.js

A distributed computing environment

class Datatypes{

  string = async(op, args)=>{
    let me = await this.literal(),
    other = args[0], result=null;

    console.log(op)
    switch(op){
      case 'upper':
        result = me.toUpperCase()
        break;
      case 'lower':
        result = me.toLowerCase()
        break;
      case 'title':
        result = "";
        me = me.split(' ').map(m=>{
          result = `${result} ${m[0].toUpperCase()}${m.slice(1).toLowerCase()}`.trim()
        })
        break;
      case 'slice':
        let start = args[0], end = args[1];
        start = start && await start.literal()
        end = end && await end.literal()

        result = me.slice(start, end)
        break;
      case 'concat':
        other = await args[0].literal()
        result = `${me}${other}`
        break;
      case 'find':
        let lst = args[1] && await args[1].literal()
        result = me[lst?'lastIndexOf': 'indexOf'](await other.literal())
        break;
      case 'includes':
        result = me.includes(await other.literal())
        break;
      case 'index':
        other = await other.literal()
        if (other < 0){
          result = me.slice(other)[0]
        }else result = me[other]
        break;
      case 'trim':
        other = args[0]
        if (other) other = await other.literal()
        else other = 0
        let char = args[1]
        if (char) char = await char.literal()
        else char = ' '

        let esc_regx_char = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

        let char_regx = esc_regx_char(char);

        switch (other) {
          case 1:
            result = me.replace(new RegExp(`^${char_regx}+`), '');
            break
          case 2:
            result = me.replace(new RegExp(`${char_regx}+$`), '');
            break
          case 0:
          default:
            result = me.replace(new RegExp(`^${char_regx}+|${char_regx}+$`, 'g'), '');
        }
        break;
      case 'length':
        result = me.length;
        break;
      case 'is_empty':
        result = !!me
        break;
      case 'is_blank':
        result = !!me.trim()
        break;
      case 'is_numeric':
        result = !!me && !isNaN(Number(me))
        break;
      case "endswith":
        result = me.endsWith(await other.literal())
        break;
      case "startswith":
        result = me.startsWith(await other.literal())
        break;
      case 'padend':
        result = me.padEnd(await other.literal(), await args[1].literal())
        break;
      case 'padstart':
        result = me.padStart(await other.literal(), await args[1].literal())
        break;
      case 'count':
        other = await args[0].literal()

        let count = 0;
        let position = 0;

        while ((position = me.indexOf(other, position)) !== -1) {
          count++;
          position += other.length;
        }
        result = count;
        break;
      case 'reverse':
        result = me.split('').reverse().join('');
        break
      case 'repeat':
        result = me.repeat(await other.literal())
        break
      case 'replace':
        let globally = args[2] && await args[2].literal(),
        keyword = await other.literal(), replacement = await args[1].literal()
        result = me.replace(keyword, replacement)
        if (globally){
          while(result.includes(keyword)) result = result.replace(keyword, replacement)
        }
        break
      case 'split':
        other = other ? await other.literal(): ' '
        result = me.split(other)
        break
      case 'charcode':
        let code = args[1] ? await args[1].literal() : 'ascii'
        if (code === 'ascii'){
          result = me.split("").map(char => char.charCodeAt(0))
        }
        
        break;
    }

    return result
  }

  number = async (op, args)=>{
    let other = args[0]

    other = other && await other.literal()
    let me = await this.literal()
    
    let result;
    switch(op){
      case '__add__':
        result = me + other;
        break;
      case '__sub__':
        result = me - other;
        break;
      case '__mul__':
        result = me * other;
        break;
      case '__div__':
        if (!other)result = { error:true, value:{name: 'ZeroDivision'}}
        else 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;
    }

    return result    
  }

  array = async(op, args, options={})=>{
    let {config, chain } = options;
    
    await this.literal()
    let other = args[0], store, result = null;

    switch(op){
      case 'push':
        result = this.lit.content_addr.push(other.value.path)
        store = true;
        break;
      case 'length':
        result = this.lit.content.length;
        break;
      case 'pop':
        if (other){
          result = this.lit.content_addr.splice(await other.literal(), 1)[0]
        }else result = this.lit.content_addr.pop()
        
        store= true

        if(result){
          result = {type:'address',value: result}
        }
        break;
      case 'extend':
        await other.literal()
        result = this.lit.content_addr.push(...other.lit.content_addr)
        store = true
        
        break;
      case 'slice':
        let start = args[0] && await args[0].literal()
        let end = args[1] && await args[1].literal()

        let new_arr = this.lit.content_addr.slice(start, end)
        result = new_arr

        let res = await this.account.vm.instantiate({type:'array', value: result, location: config.location}, {chain, pure: true})

        result = {type:'address', value: res}
        break;
      case 'splice':
        let spl_replacement = args[2]
        if (spl_replacement){
          result = this.lit.content_addr.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal(), spl_replacement.value.path )
        }else result = this.lit.content_addr.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal())
        
        store = true;

        result = {type:'address', value: await this.account.vm.instantiate({type:'array', value: result, location: config.location}, {chain, pure: true})}

        break;
      case 'index':
        other = await other.literal()
        if (typeof other === 'number'){
          if (other <0){
            result = this.lit.content_addr.slice(other)[0]
          }else result = this.lit.content_addr[other];
        }
        if (result) result = {type:'address', value: result}
        break;
      case 'to_string':
        other = other && await other.literal()

        result = ''
        for (let i=0; i< this.lit.content_addr.length; i++){
          let item = this.lit.content_addr[i];

          let cont = await this.account.vm.resolve_address(item);
          cont = await this.account.vm.cloth_content(cont)
          cont = await cont.literal()
          if (other === 'ascii'){
            if (typeof cont === 'number'){
              result = `${result}${String.fromCharCode(cont)}`
            }else result = `${result}void`
          }else result = `${result}${cont}`
        }
        break;
      case 'is_empty':
        result = !this.lit.content_addr.length
        break;
      case 'clear':
        this.lit.content_addr = []
        store = true;
        break
      case "join":
        let str_val = ''
        let separator = (other && await other.literal()) || ','
        for (let i=0; i< this.lit.content_addr.length; i++){
          let item = this.lit.content_addr[i]
          let val = await this.account.vm.cloth_content(await this.account.vm.resolve_address(item))

          let cont = await val.literal()
          if (['number', 'string', 'void', 'boolean'].includes(typeof cont))str_val = `${str_val}${i ? separator: ''}${cont}`
        }
        result = str_val
        break;
      case 'map':
        let confg = other.value;
        let map_arr = []
        for (let i=0; i< this.lit.content_addr.length; i++){
          let item = this.lit.content_addr[i];
          
          let res = await this.account.vm.execute(confg, {call_config: {
            identifier: confg.address,
            arguments: [
              {type:'address', value: item, position: 0},
              {...await this.account.vm.parse_aircode(i, {config, chain}), position:1}
            ],
            location: config.location
          }, chain})
          if (res && res.type!== 'address'){
            console.log("Datatypes.js:Query")
          }
          map_arr.push(res.value)
        }
        if (args[1] && await args[1].literal()){
          this.lit.content_addr = map_arr
          store = true
        }else result = {type:'address', value: await this.account.vm.instantiate({type:'array', value: map_arr, location: config.location}, {chain, pure: true})}
        
        break;
      case 'filter':
        let fconfg = other.value;
        let fil_arr = []
        for (let i=0; i< this.lit.content_addr.length; i++){
          let item = this.lit.content_addr[i];
          
          let res = await this.account.vm.execute(fconfg, {call_config: {
            identifier: fconfg.address,
            arguments: [
              {type:'address', value: item, position: 0},
              {...await this.account.vm.parse_aircode(i, {config, chain}), position:1}
            ],
            location: config.location
          }, chain, cloth: true})
          
          if (res && !!await res.literal())
            fil_arr.push(item)
        }
        if (args[1] && await args[1].literal()){
          this.lit.content_addr = fil_arr
          store = true
        }else result = {
          type:'address', 
          value: await this.account.vm.instantiate({
            type:'array', 
            value: fil_arr, 
            location: config.location}, 
            {chain, pure: true})
        }
        
        break;
      case 'find':
        let fnconfg = other.value;
        for (let i=0; i< this.lit.content_addr.length; i++){
          let item = this.lit.content_addr[i];
          
          let index = await this.account.vm.parse_aircode(i, {config, chain})
          let res = await this.account.vm.execute(fnconfg, {call_config: {
            identifier: fnconfg.address,
            arguments: [
              {type:'address', value: item, position: 0},
              {...index, position:1}
            ],
            location: config.location
          }, chain, cloth: true})
          
          if (res && !!await res.literal())
            {
            result = index
            break
            }
        }
      case 'includes':
        other = await other.literal()
        for (let i=0; i< this.lit.content_addr.length; i++){
          let item = this.lit.content_addr[i];
          let val = await this.account.vm.cloth_content(await this.account.vm.resolve_address(item))

          if (await val.literal() === other){
            result = true;
            break
          }
        }
        result = result || false
        break;
      case 'copy':
        result = {
          type:'address', 
          value: await this.account.vm.instantiate({
            type:'array', 
            value: [...this.lit.content_addr], 
            location: config.location}, 
            {chain, pure: true})
        }
        break;
      case 'reverse':
        this.lit.content_addr.reverse()
        store = true
        break;
    }

    if (store) {
      let oracle = this.account.manager.oracle
      let obj = {content: JSON.stringify(this.lit.content_addr), __classifier__: 'array', uid: this.lit.uid}
      
      let path_split = this.value.path.split('/')
      await oracle.fs.store(obj, {path: path_split.slice(0,-1).join('/'), hash: path_split[path_split.length-1], is_instance: true, type: 'twain'})
    }

    return result
  }

  twain = async(op, args, options)=>{
    let {config, chain} = options
    await this.literal()

    let result = null, store, other = args[0];
    switch(op){
      case 'entries':
        result = []
        for (let p in this.lit.content_addr){
          let pair = this.lit.content_addr[p]

          result.push(await this.account.vm.instantiate({
            type:'array', 
            value: pair, 
            location: config.location}, 
            {chain, pure: true}))
        }
        result = {type:'address', value: await this.account.vm.instantiate({
          type:'array', 
          value: result, 
          location: config.location}, 
          {chain, pure: true})
        }
        break;
      case 'keys':
        result = []
        for (let p in this.lit.content_addr){
          let pair = this.lit.content_addr[p]

          result.push(pair[0])
        }
        result = {type:'address', value: await this.account.vm.instantiate({
          type:'array', 
          value: result, 
          location: config.location}, 
          {chain, pure: true})
        }
        break;

      case 'values':
        result = []
        for (let p in this.lit.content_addr){
          let pair = this.lit.content_addr[p]

          result.push(pair[1])
        }
        result = {type:'address', value: await this.account.vm.instantiate({
          type:'array', 
          value: result, 
          location: config.location}, 
          {chain, pure: true})
        }
        break;
      case 'get':
        if(typeof other === 'string'){}
        else other = other && await other.literal()

        let hash = await this.account.manager.oracle.hash(other, 'sha1')
        let val = this.lit.content_addr[hash]
        if (val)result = {type: 'address', value: val[1]}
        break;
      case 'set':
        other = other && await other.literal()
        let shash = await this.account.manager.oracle.hash(other, 'sha1')
        
        this.lit.content_addr[shash] = [args[0].value.path, args[1].value.path]
        store = true;
        break;
      case 'remove':
        other = other && await other.literal()
        let rhash = await this.account.manager.oracle.hash(other, 'sha1')
        let rval = this.lit.content_addr[rhash]
        if(rval)result = true
        else result = false;
        
        delete this.lit.content_addr[rhash]
        store = true;
        break
      case 'copy':
        result = {type:'address', value: await this.account.vm.instantiate({
          type:'twain', 
          value: this.lit.content_addr, 
          location: config.location}, 
          {chain, pure: true})
        }
        break;
      case 'clear':
        this.lit.content_addr = {}
        store = true;
        break

    }

    if (store) {
      let oracle = this.account.manager.oracle
      let obj = {content: JSON.stringify(this.lit.content_addr), __classifier__: 'twain', uid: this.lit.uid}
      
      let path_split = this.value.path.split('/')
      await oracle.fs.store(obj, {path: path_split.slice(0,-1).join('/'), hash: path_split[path_split.length-1], is_instance: true, type: 'twain'})
    }

    return result
  }

  factorial = (value)=>{
    if (value === 0)
      return 1
    return value * this.factorial(value - 1)
  }
}

export default Datatypes;