sclass ActualThoughtSpace extends AbstractThoughtSpace {
  new TripleIndex index;
  int limit; // 0 = no limit
  L<Triple<S>> blockedPatterns = listWithNotify(r { blocked.clear(); });
  Map<TripleWeb, Bool> blocked = newWeakHashMap();

  *() {}
  *(int *limit) {}
  *(AbstractThoughtSpace parent) { super(parent); }
  
  // existence of triple has already been checked
  public GlobalID postTriple(T3<S> t) {
    if (limitReached()) fail("Thought space limit reached");
    TripleWeb w = tripleWeb(t);
    index.addTriple(w);
    ret w.globalID();
  }
  
  bool limitReached() {
    ret limit > 0 && size() >= limit;
  }
  
  L<TripleRef<S>> get(S s) {
    ret ai_triplesToTripleRefs_lazyList(s, getTriples(s));
  }
  
  L<TripleWeb> getTriples(S s) {
    L<TripleWeb> l = filterNonBlockedTriples(parent.getTriples(s));
    ret combineLists(l, index.getTriples(ai_shortenForIndex(s)));
  }
  
  L<TripleRef<S>> filterNonBlocked(L<TripleRef<S>> l) {
    if (empty(blockedPatterns)) ret l;
    L<TripleRef<S>> out = emptyListWithCapacity(l);
    for (TripleRef<S> ref : l)
      if (!isBlocked((TripleWeb) ref.triple))
        out.add(ref);
    ret out;
  }
  
  L<TripleWeb> filterNonBlockedTriples(L<TripleWeb> l) {
    if (empty(blockedPatterns)) ret l;
    L<TripleWeb> out = emptyListWithCapacity(l);
    for (TripleWeb w : l)
      if (!isBlocked(w))
        out.add(w);
    ret out;
  }
  
  bool isBlocked(TripleWeb t) {
    Bool b = blocked.get(t);
    if (b != null) ret b;
    b = false;
    for (T3<S> pat : blockedPatterns)
      if (simpleMatchTriple_dollarVars(pat, t) != null) {
        b = true;
        break;
      }
    blocked.put(t, b);
    ret b;
  }
  
  int size() { ret index.size(); }
}