constructor(public func: HandlerFunc | null, public label: string) {

    this.patterns = []; // s,p,o,g quads that should trigger the next run

    this.innerHandlers = []; // Handlers requested while this one was running

  }

}

export class AutoDependencies {

  handlers: Handler;

  handlerStack: Handler[];

  constructor() {

    // tree of all known Handlers (at least those with non-empty

    // patterns). Top node is not a handler.

    this.handlers = new Handler(null, "root");

    this.handlerStack = [this.handlers]; // currently running

  }

  runHandler(func: HandlerFunc, label: string) {

    // what if we have this func already? duplicate is safe?

    if (label == null) {

      throw new Error("missing label");

    }

    const h = new Handler(func, label);

    const tailChildren = this.handlerStack[this.handlerStack.length - 1].innerHandlers;

    // ohno, something depends on some handlers getting run twice :(

    if (matchingLabel < 2) {

      tailChildren.push(h);

    }

    //console.time("handler #{label}") 

    // todo: this may fire 1-2 times before the

    // graph is initially loaded, which is a waste. Try deferring it if we

    // haven't gotten the graph yet.

  }

  //console.timeEnd("handler #{label}")

  //@_logHandlerTree()

  _rerunHandler(handler: Handler, patch?: Patch) {

    handler.patterns = [];

    this.handlerStack.push(handler);

    try {

      if (handler.func === null) {

        throw new Error("tried to rerun root");

      }

      handler.func(patch);

    } catch (e) {

      log("error running handler: ", e);

    } finally {

      // assuming here it didn't get to do all its queries, we could

      // add a *,*,*,* handler to call for sure the next time?

      // log('done. got: ', handler.patterns)

      this.handlerStack.pop();

    }

  }

  // handler might have no watches, in which case we could forget about it

  _logHandlerTree() {

    log("handler tree:");

    var prn = function (h: Handler, depth: number) {

      let indent = "";

      for (let i = 0; i < depth; i++) {

        indent += "  ";

      }

      log(`${indent} \"${h.label}\" ${h.patterns.length} pats`);

    };

  }

  _handlerIsAffected(child: Handler, patchSubjs: Set<string>) {

    if (patchSubjs === null) {

      return true;

    }

    if (!child.patterns.length) {

      return false;

    }

    for (let stmt of Array.from(child.patterns)) {

      if (stmt.subject === null) {

        // wildcard on subject

        return true;

      }

      if (patchSubjs.has(stmt.subject.value)) {

        return true;

      }

    }

    return false;

  }

  graphChanged(patch: Patch) {

    // SyncedGraph is telling us this patch just got applied to the graph.

    const subjs = allPatchSubjs(patch);

    var rerunInners = (cur: Handler) => {

      const toRun = cur.innerHandlers.slice();

      for (let child of Array.from(toRun)) {

        //match = @_handlerIsAffected(child, subjs)

        //continue if not match

        //log('match', child.label, match)

        //child.innerHandlers = [] # let all children get called again

        this._rerunHandler(child, patch);

        rerunInners(child);

      }

    };

  }

  askedFor(s: Quad_Subject | null, p: Quad_Predicate | null, o: Quad_Object | null, g: Quad_Graph | null) {

    // SyncedGraph is telling us someone did a query that depended on

    // quads in the given pattern.

    const current = this.handlerStack[this.handlerStack.length - 1];

    if (current != null && current !== this.handlers) {

    }

  }

}

    this._autoDeps.graphChanged(patch);

  }

  getObjectPatch(s: N3.NamedNode, p: N3.NamedNode, newObject: N3.Quad_Object, g: N3.NamedNode): Patch {

    // make a patch which removes existing values for (s,p,*,c) and

    // adds (s,p,newObject,c). Values in other graphs are not affected.

    const existing = this.graph.getQuads(s, p, null, g);

    return {

      dels: existing,

      adds: [this.Quad(s, p, newObject, g)],

    };

  }

  patchObject(s: N3.NamedNode, p: N3.NamedNode, newObject: N3.Quad_Object, g: N3.NamedNode) {

    this.applyAndSendPatch(this.getObjectPatch(s, p, newObject, g));

  }

  clearObjects(s: N3.NamedNode, p: N3.NamedNode, g: N3.NamedNode) {

    return this.applyAndSendPatch({

      dels: this.graph.getQuads(s, p, null, g),

      adds: [],

    });

  }

    // runs your func once, tracking graph calls. if a future patch

    // matches what you queried, we runHandler your func again (and

    // forget your queries from the first time).

    // helps with memleak? not sure yet. The point was if two matching

    // labels get puushed on, we should run only one. So maybe

    // appending a serial number is backwards.

    if (!this.serial) {

      this.serial = 1;

    }

    this.serial += 1;

    //label = label + @serial

    this._autoDeps.runHandler(func, label);

  }

  _singleValue(s: Quad_Subject, p: Quad_Predicate) {

    this._autoDeps.askedFor(s, p, null, null);

    const quads = this.graph.getQuads(s, p, null, null);

    const objs = new Set(Array.from(quads).map((q: Quad) => q.object));

    switch (objs.size) {

      case 0:

        throw new Error("no value for " + s.value + " " + p.value);