sclass WebRelation extends WebNode {
  WebNode a, b;
  
  public void _setField(S f, O x) {
    if (f.equals('a)) a = (WebNode) x;
    else if (f.equals('b)) b = (WebNode) x;
    else super._setField(f, x);
  }
  
  *() {}
  *(Web web, WebNode a, WebNode b) { super(web); this.a = a; this.b = b; }
}

sclass Web {
  new L<WebNode> nodes; // Relations are also nodes
  ifdef WebWithRelationsMap
  Map<Pair<WebNode>, WebRelation> relations = new Map;
  endifdef
  ifdef WebWithIndex
  MultiMap<Lisp, WebNode> index; // label -> node
  endifdef
  ifndef WebWithIndex
  static final MultiMap<Lisp, WebNode> index = null;
  endifndef
  //Map<S, L<WebNode>> pots = new Map;
  ifdef WebWithLock
  transient Lock lock = reentrantLock(true);
  endifdef
  //int size;
  //int flags; // TODO
  bool useCLParse = true;
  bool labelsToUpper;
  S title;
  O globalID = aGlobalIDObj();
  S source;
  bool unverified;
  long created = nowUnlessLoading();
  
  static new L onNewNode; // L<voidfunc(WebNode)>
  static new L onNewLabel; // L<voidfunc(WebNode, Lisp)>
  
  static int F_useCLParse = 1;
  static int F_labelsToupper = 2;
  static int F_unverified = 3;
  
  /*bool potNotEmpty(S pot) { ret nempty(getPot(pot)); }
  
  L<WebNode> clearPot(S pot) {
    L<WebNode> l = getPot(pot);
    L<WebNode> l2 = cloneList(l);
    l.clear();
    ret l2;
  }*/
  
  /*L<WebNode> getPot(S pot) {
    L<WebNode> l = pots.get(pot);
    if (l == null)
      pots.put(pot, l = cloneList(nodes));
    ret l;
  }*/
  
  void relation(WebNode a, S arrow, WebNode b) {
    getRelation(a, b).addLabel(arrow);
  }
  
  Pair<WebNode> relation(S a, S arrow, S b) {
    ret relation(lisp(arrow, a, b));
  }
  
  Pair<WebNode> relation(Lisp l) {
    if (l(l) == 1) {
      findNode(l.get(0)).addLabel(lisp("wvuyakuvuelmxpwp", l.head));
      null;
    } else if (l(l) == 2) {
      S a = lisp2label(l.get(0)), b = lisp2label(l.get(1));
      if (l.is("fgvvrzypbkqomktd")) { // X is Y.
        findNode(a).addLabel(b);
        findNode(b).addLabel(a);
      }
      WebNode na = findNode(a), nb = findNode(b);
      getRelation(na, nb).addLabel(l.head);
      ret pair(na, nb);
    }
    null;
  }
  
  void relations(L<Lisp> l) {
    for (Lisp li : l) relation(li);
  }
  
  WebRelation getRelation(S a, S b) {
    ret getRelation(findNode(a), findNode(b));
  }
  
  WebRelation getRelation(WebNode a, WebNode b) {
    ret getRelation(pair(a, b));
  }
  
  WebRelation relation(WebNode a, WebNode b) { ret getRelation(a, b); }
  WebRelation relation(Pair<WebNode> p) { ret getRelation(p); }
  
  WebRelation getRelationOpt(Pair<WebNode> p) {
    ret getRelationOpt(p.a, p.b);
  }
  
  WebRelation getRelationOpt(WebNode a, WebNode b) {
    ifdef WebWithRelationsMap
    if (relations != null)
      ret relations.get(pair(a, b));
    endifdef
    for (WebNode n : nodes)
      if (n instanceof WebRelation) {
        WebRelation r = n/WebRelation;
        if (r.a == a && r.b == b)
          ret r;
      }
    null;
  }
  
  WebRelation getRelation(Pair<WebNode> p) {
    WebRelation r = getRelationOpt(p.a, p.b);
    if (r == null) {
      r = _newRelation(p.a, p.b);
      ifdef WebWithRelationsMap
      if (relations != null) relations.put(p, r);
      endifdef
    }
    ret r;
  }
  
  WebRelation _newRelation(WebNode a, WebNode b) {
    WebRelation r = new WebRelation(this, a, b);
    nodes.add(r);
    //for (L<WebNode> l : values(pots)) l.add(r);
    ret r;
  }
  
  WebNode newNode() {
    WebNode node = new WebNode(this);
    nodes.add(node);
    //for (L<WebNode> l : values(pots)) l.add(node);
    ret node;
  }
  
  WebNode newNode(S s) {
    WebNode node = newNode();
    node.addLabel(parseLabel(s));
    ret node;
  }
  
  WebNode node(S s) { ret findNode(s); }
  WebNode node(Lisp l) { ret findNode(l); }

  WebNode findNode(S s) {
    ret findNode(parseLabel(s));
  }
  
  WebNode findNode(Lisp l) {
    WebNode n = findNodeOpt(l);
    ret n != null ? n : newNode(l);
  }
  
  WebNode findNodeOpt(Lisp l) {
    if (index != null) ret first(index.get(l));
    for (WebNode n : nodes) if (n.hasLabel(l)) ret n;
    null;
  }
  
  WebNode newNode(S... labels) {
    WebNode n = newNode();
    for (S label : labels) n.addLabel(label);
    ret n;
  }
  
  WebNode newNode(Lisp... labels) {
    WebNode n = newNode();
    for (Lisp label : labels) n.addLabel(label);
    ret n;
  }
  
  toString { ret webToString(this); }
  
  void index(Lisp label, WebNode n) {
    if (index != null) index.put(label, n);
    fireNewLabel(n, label);
  }
  
  void clear {
    clearAll(nodes, index/*, pots*/);
    ifdef WebWithRelationsMap
    main clear(relations);
    endifdef
  }
  
  Lisp parseLabel(S s) {
    ifndef noCLParse
      if (useCLParse) ret clParse(s);
    endifndef
    ret lisp(labelsToUpper ? upper(s) : s);
  }
  
  S unparseLabel(Lisp l) {
    ifndef noCLParse
      if (useCLParse) ret clUnparse(l);
    endifndef
    ret lispHead(l);
  }
  
  L<Lisp> parseLabels(L<S> l) {
    L<Lisp> x = new L(l(l));
    for (S s : l) x.add(parseLabel(s));
    ret x;
  }
  
  L<S> unparseLabels(L<Lisp> l) {
    L<S> x = new L(l(l));
    for (Lisp lbl : l) x.add(unparseLabel(lbl));
    ret x;
  }
  
  void fireNewNode(WebNode node) { for (O f : onNewNode) pcallF(f, node); }
  void fireNewLabel(WebNode node, Lisp label) { for (O f : onNewLabel) pcallF(f, node, label); }
  
  void removeNode(WebNode n) {
    if (n == null || !nodes.contains(n)) ret;
    
    n.web = null;
    
    ifdef WebWithRelationsMap
    // TODO
    L<Pair<WebNode>> relationsToDelete = pairList_lookupAnySide(keys(relations), n);
    endifdef
    
    if (index != null) for (Lisp label : n.labels())
      index.remove(label, n);
    nodes.remove(n);

    ifdef WebWithRelationsMap
    for (Pair<WebNode> p : relationsToDelete)
      removeRelation(p.a, p.b);
    endifdef
  }
  
  void removeRelation(WebNode a, WebNode b) {
    Pair<WebNode> p = pair(a, b);
    WebNode r = getRelationOpt(p);
    if (r == null) ret;
    ifdef WebWithRelationsMap
    relations.remove(p);
    endifdef
    removeNode(r);
  }
  
  bool verified() { ret !unverified; }
  
  S globalID() { ret strOrNull(globalID); }
  GlobalID globalIDObj() {
    ret globalID instanceof S
      ? GlobalID((S) globalID)
      : (GlobalID) globalID;
  }
  void setGlobalID(S id) { globalID = asGlobalID(id); }
  
  public int hashCode() { ret globalIDObj().hashCode(); }
  public bool equals(O o) {
    ret o instanceof Web && eq(globalIDObj(), o/Web.globalIDObj());
  }
}

Began life as a copy of #1007660