godprotocol/Datatypes/func.js

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

import { copy_object } from "generalised-datastore/utils/functions.js";
import Storage from "godprotocol/Datatypes/functions/storage.js";

class Func extends Storage {
  constructor(config, account) {
    super(account);

    this.config = config;
    this.type = "function";
  }

  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;
  }

  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;