Class Scan

src/runtime/join.ts:117–342

// You specify a triple that they should look for which can have variables
// or constant values for e, a, or v that we'll attempt to solve for.
export class Scan {
  id: string;
  // array representation of the eav
  eav: any[];
  // a "bitmap" for what variables this scan is solving for
  // we use index as the key and the variable as the value
  vars: Variable[];
  // blown out eav for convenience
  e: any;
  a: any;
  v: any;
  node: any;
  proposalObject: Proposal;
  resolved: any[];
  scopes: string[];

  constructor(id: string, e,a,v,node?,scopes?) {
    this.id = id;
    this.resolved = [];
    this.eav = [e,a,v,node];
    this.e = e;
    this.a = a;
    this.v = v;
    this.node = node;
    this.proposalObject = {providing: null, index: [], cardinality: 0};
    this.scopes = scopes || ["session"];

    // check if any of the supplied params are variables and store them
    this.vars = [];
    for(let register of this.eav) {
      if(isVariable(register)) {
        this.vars[register.id] = register;
      }
    }
  }

  // Return an array of the current values for all the registers
  resolve(prefix) {
    let resolved = this.resolved;
    resolved[0] = toValue(this.e, prefix);
    resolved[1] = toValue(this.a, prefix);
    resolved[2] = toValue(this.v, prefix);
    resolved[3] = toValue(this.node, prefix);
    return resolved;
  }


  _fullScanLookup(index, solving, results, resolved, solvingIx, ix, maxDepth) {
    if(index === undefined) return;
    if(ix === maxDepth) {
      return results.push(solving.slice());
    }
    let value = resolved[ix];
    if(value === undefined) {
      let curIndex = index.index;
      for(let key of Object.keys(curIndex)) {
        let v = curIndex[key];
        solving[solvingIx] = v.value !== undefined ? v.value : v;