transient srecord noeq G22NetworkInstance(G22Network network) {

  new Map<S, Value> valuesByIdentifier;

  new Map<G22NetworkElement, Value> valuesByBlueprint;

  event dirtyStatesChanged;

  sclass Value {

    settable O object; // the actual value calculated by the node

    settable Timestamp calculatedWhen; // when the value was calculated

    settable volatile bool dirty; // does this node need recalculation?

    settable volatile bool calculating; // are we recalculating right now?

    settable volatile Throwable error; // error during calculation?

    O get() { ret object; }

    toString { ret classNameWithIdentity(this) + ": " + object; }

    bool hasError() { ret error != null; }

  }

  void calculateNode(G22Utils g22utils, G22NetworkElement e) {

    if (e == null) ret;

    Value value = valueForBlueprint(e);

    value.calculating(true);

    try {

      dirtyStatesChanged();

      O instance = e.makeInstance(g22utils, this);

      print("Calculated: " + instance);

      value.error(null);

      setObject(e, value, instance);

    } catch print exception {

      value.error(exception);

      value.dirty(false);

    } finally {

      value.calculating(false);

      dirtyStatesChanged();

    }

  }

  void setObject(G22NetworkElement e, Value value, O instance) {

    value.object(instance).calculatedWhen(tsNow());

    if (value.dirty()) {

      value.dirty(false);

      dirtyStatesChanged();

    }

    invalidateDependentNodes(e);

  }

  void init(G22Utils g22utils) {

    // make empty Value object for each node

    for (e : network.elements) {

      new Value value;

      value.dirty(true);

      dirtyStatesChanged();

      valuesByBlueprint.put(e, value);

      //print("Put value in map: " + e + " => " + value);

      mapPut(valuesByIdentifier, e.identifier(), value);

    }

  }

  O getObjectForBlueprint(G22NetworkElement element) {

    var value = valueForBlueprint(element);

    O object = value!;

    printVars("getObjectForBlueprint", +element, +value, +object);

    ret object;

  }

  void invalidateDependentNodes(G22NetworkElement element) {

    if (element == null) ret;

    print("invalidateDependentNodes", element);

    for (e : element.downstreamNodes())

      invalidateNode(e);

  }

  // a node is calculable if its upstream nodes (the inputs

  // it needs) are clean

  bool isCalculable(G22NetworkElement element) {

    ret all(element.upstreamNodes(), e -> !isDirty(e));

  }

  Value valueForBlueprint(G22NetworkElement element) {

    ret syncGetOrCreate(valuesByBlueprint, element, -> new Value);

  }

  bool isDirty(G22NetworkElement element) {

    ret valueForBlueprint(element).dirty();

  }

  void invalidateNode(G22NetworkElement element) {

    print("invalidateNode", element);

    var value = valueForBlueprint(element);

    if (value.dirty()) ret; // Node already dirty

    value.dirty(true);

    dirtyStatesChanged();

    invalidateDependentNodes(element);

  }

  // select any calculable node and calculate it

  G22NetworkElement calculateOneNode(G22Utils g22utils) {

    var calculableElements = filter(

      e -> isDirty(e) && isCalculable(e),

      keys(valuesByBlueprint));

    var e = random(calculableElements);

    calculateNode(g22utils, e);

    ret e;

  }

}