godprotocol/Objects/Datatypes.js

A distributed computing environment for Web 4.0 — integrating AI, decentralisation, and virtual computation.

class Datatypes {
  constructor(){}

  insert = async({arr, item, index})=>{
    let folder = await this.folder()
    
    if (index === arr.length){
      let item_folder = await folder.folder(index.toString())

      let res = await item_folder.write(item, {replace: true})
      arr.length ++
      arr.value = res.datapath
    }else {
      let ref;
      while (index <= arr.length){
        let item_folder = await folder.folder(index.toString())
        let curr_item = await item_folder.readone()
        ref = await item_folder.write(item, {replace: true})
        item = curr_item
        index ++
      }
      arr.length ++
      arr.value = ref.datapath
    }

    await folder.write(arr, {replace: true})
  }

  pop = async({arr, index})=>{
    let folder = await this.folder(), popped;
    
    while (index < arr.length){
      let index_folder = await folder.folder(index.toString())

      if (!popped){
        popped = await index_folder.readone()
      }
      index++
      if (index < arr.length){
        let next_item = await folder.folder(index.toString())
        next_item = await next_item.readone()
        await index_folder.write(next_item, {replace: true})
      }
    }
    
    arr.length --

    await folder.write(arr, {replace: true})
    return popped
  }

  index = async ({i}) => {
    let folder = await this.folder()

    let item_folder = await folder.folder(i.toString())
    return (await item_folder.readone())
  }

  get = async({twa, key})=>{
    let folder = await this.folder()

    let child = await folder.folder(key)
    let res = (await child.readone())

    if(!res) return null;

    if (res.deleted) res = null

    return res.value;
  }

  set = async({twa, key, prop, value}) => {
    let folder = await this.folder()
    let pair_folder = await folder.folder(key)
    let {vm} = this.account;
    
    await (await pair_folder.folder('__prop__')).write(prop)

    let prev = (await pair_folder.readone()), addr;
    
    if (prev && prev.created < twa.created) prev = null
    if (prev && prev.deleted) prev = null

    if (!prev){
      if (twa.value){
        let o = this._split_datapath(twa.value)
        o = {value: o[0], _id: o[1], type: 'address'}
        prev = await vm.cloth(o, {just_content: true})
        prev = await vm.cloth_content(prev.value)

        let res = await pair_folder.write({value, prev: twa.value}, {replace: true})
        addr = res.datapath
        
        let p_folder = await this.account.manager.ds.folder(`${o.value}`)
        await p_folder.update({_id: o._id}, {next: addr})
      }else {
        addr = await pair_folder.write({value}, {replace: true})
        addr = addr.datapath
      }
      twa.value = addr
      await folder.write(twa, {replace: true})
      return addr;
    }

    await pair_folder.update({_id: prev._id}, {value})
  }

  _split_datapath = (datapath)=>{
    datapath = datapath.split('/')

    return [datapath.slice(0,-1).join('/'), datapath.slice(-1)[0]]
  }

  remove = async({twa, key})=>{
    let {folder:fold} = this.account.manager.ds
    let folder = await this.folder()
    let child = await folder.folder(key)

    let val = await child.readone()
    if (!val || (val && val.deleted)) return false;

    await child.update({_id: val._id}, {deleted: true})
    
    if (val.prev){
      let o = this._split_datapath(val.prev)
      let pv = await fold(o[0])
      await pv.update({_id: o[1]}, {next: val.next})
    }
    if (val.next){
      let o = this._split_datapath(val.next)
      let nx = await fold(o[0])
      await nx.update({_id: o[1]}, {prev: val.prev})
    }
    
    if (twa.value && twa.value.startsWith(child.address)){
      if (val.next){
        console.log("RAISE AN EYEBROW - Datatypes.remove")
      }
      twa.value = val.prev
    }
    await folder.write(twa, {replace: true})
    return true;
  }
}

export default Datatypes;