The returned list iterator is fail-fast.
*
* @see #listIterator(int)
*/
public ListIterator listIterator() {
return new ListItr(0);
}
/**
* Returns an iterator over the elements in this list in proper sequence.
*
* The returned iterator is fail-fast.
*
* @return an iterator over the elements in this list in proper sequence
*/
public Iterator iterator() {
return new Itr();
}
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public A next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = SynchronizedArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (A) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
SynchronizedArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/**
* An optimized version of AbstractList.ListItr
*/
private class ListItr extends Itr implements ListIterator {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
@SuppressWarnings("unchecked")
public A previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = SynchronizedArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (A) elementData[lastRet = i];
}
public void set(A e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
SynchronizedArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(A e) {
checkForComodification();
try {
int i = cursor;
SynchronizedArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
public List subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
static void subListRangeCheck(int fromIndex, int toIndex, int size) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > size)
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
}
private class SubList extends SynchronizedArrayList_Base implements RandomAccess {
private final SynchronizedArrayList_Base parent;
private final int parentOffset;
private final int offset;
int size;
SubList(SynchronizedArrayList_Base parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = SynchronizedArrayList.this.modCount;
}
public A set(int index, A e) {
rangeCheck(index);
checkForComodification();
A oldValue = SynchronizedArrayList.this.elementData(offset + index);
SynchronizedArrayList.this.elementData[offset + index] = e;
return oldValue;
}
public A get(int index) {
rangeCheck(index);
checkForComodification();
return SynchronizedArrayList.this.elementData(offset + index);
}
public int size() {
checkForComodification();
return this.size;
}
public void add(int index, A e) {
rangeCheckForAdd(index);
checkForComodification();
parent.add(parentOffset + index, e);
this.modCount = parent.modCount();
this.size++;
}
public A remove(int index) {
rangeCheck(index);
checkForComodification();
A result = parent.remove(parentOffset + index);
this.modCount = parent.modCount();
this.size--;
return result;
}
public void removeRange(int fromIndex, int toIndex) {
checkForComodification();
parent.removeRange(parentOffset + fromIndex,
parentOffset + toIndex);
this.modCount = parent.modCount();
this.size -= toIndex - fromIndex;
}
public boolean addAll(Collection c) {
return addAll(this.size, c);
}
public boolean addAll(int index, Collection c) {
rangeCheckForAdd(index);
int cSize = c.size();
if (cSize==0)
return false;
checkForComodification();
parent.addAll(parentOffset + index, c);
this.modCount = parent.modCount();
this.size += cSize;
return true;
}
public Iterator iterator() {
return listIterator();
}
public ListIterator listIterator(final int index) {
checkForComodification();
rangeCheckForAdd(index);
final int offset = this.offset;
return new ListIterator() {
int cursor = index;
int lastRet = -1;
int expectedModCount = SynchronizedArrayList.this.modCount;
public boolean hasNext() {
return cursor != SubList.this.size;
}
@SuppressWarnings("unchecked")
public A next() {
checkForComodification();
int i = cursor;
if (i >= SubList.this.size)
throw new NoSuchElementException();
Object[] elementData = SynchronizedArrayList.this.elementData;
if (offset + i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (A) elementData[offset + (lastRet = i)];
}
public boolean hasPrevious() {
return cursor != 0;
}
@SuppressWarnings("unchecked")
public A previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = SynchronizedArrayList.this.elementData;
if (offset + i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (A) elementData[offset + (lastRet = i)];
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
SubList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = SynchronizedArrayList.this.modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void set(A e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
SynchronizedArrayList.this.set(offset + lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(A e) {
checkForComodification();
try {
int i = cursor;
SubList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = SynchronizedArrayList.this.modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (expectedModCount != SynchronizedArrayList.this.modCount)
throw new ConcurrentModificationException();
}
};
}
public List subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(parent, offset, fromIndex, toIndex);
}
private void rangeCheck(int index) {
if (index < 0 || index >= this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void rangeCheckForAdd(int index) {
if (index < 0 || index > this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+this.size;
}
private void checkForComodification() {
if (SynchronizedArrayList.this.modCount != this.modCount)
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void sort(Comparator c) {
final int expectedModCount = modCount;
Arrays.sort((A[]) elementData, 0, size, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
}
abstract static class SynchronizedArrayList_Base extends AbstractList {
final int modCount() { return modCount; }
public void removeRange(int i, int j) { super.removeRange(i, j); }
}
// better modulo that gives positive numbers always
static int mod(int n, int m) {
return (n % m + m) % m;
}
static BigInteger mod(BigInteger n, int m) {
return n.mod(bigint(m));
}
static String _compactString(String s) {
return s;
}
static String upper(String s) {
return s == null ? null : s.toUpperCase();
}
static void clearAll(Object... l) {
for (Object o : l) callOpt(o, "clear");
}
static void put(Map map, A a, B b) {
if (map != null) map.put(a, b);
}
static Iterator iterator(Collection c) {
return c == null ? emptyIterator() : c.iterator();
}
static String strOrNull(Object o) {
return o == null ? null : str(o);
}
static Lisp clParse(String s) {
List tok = tok_groupRoundBrackets(s);
if (l(tok) == 1) return null;
Lisp l = lisp(unquote(tok.get(1)));
for (int i = 3; i < l(tok); i += 2) {
String t = tok.get(i);
if (t.startsWith("(") && t.endsWith(")"))
l.add(assertNotNull(clParse(dropFirstAndLast(t))));
else
l.add(lisp(aiUsing(unquote(t))));
}
return l;
}
static List clParse(List l) {
return map("clParse", l);
}
static int _hashCode(Object a) {
return a == null ? 0 : a.hashCode();
}
static void ai_onNewOrRemovedWeb(Object onNewWeb, Object onRemovedWeb) {
ai_onNewWeb(onNewWeb);
if (onRemovedWeb != null)
onTransientWebRemoved_do(onRemovedWeb);
}
static String assertGlobalID(String s) {
return assertPossibleGlobalID(s);
}
static String quoteIfNotIdentifier(String s) {
if (s == null) return null;
return isJavaIdentifier(s) ? s : quote(s);
}
static GlobalID globalIDFromParts(long a, short b) {
GlobalID id = new GlobalID();
id.a = a;
id.b = b;
return id;
}
static long globalIDPart1(GlobalID id) {
return id == null ? 0 : id.a;
}
static List subList(List l, int startIndex) {
return subList(l, startIndex, l(l));
}
static List subList(List l, int startIndex, int endIndex) {
startIndex = max(0, min(l(l), startIndex));
endIndex = max(0, min(l(l), endIndex));
if (startIndex > endIndex) return litlist();
return l.subList(startIndex, endIndex);
}
static short globalIDPart2(GlobalID id) {
return id == null ? 0 : (short) id.b;
}
static Map cloneMap(Map map) {
if (map == null) return litmap();
// assume mutex is equal to collection
synchronized(map) {
return map instanceof TreeMap ? new TreeMap(map)
: map instanceof LinkedHashMap ? new LinkedHashMap(map)
: new HashMap(map);
}
}
static void set(Object o, String field, Object value) {
if (o instanceof Class) set((Class) o, field, value);
else try {
Field f = set_findField(o.getClass(), field);
smartSet(f, o, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static void set(Class c, String field, Object value) {
try {
Field f = set_findStaticField(c, field);
smartSet(f, null, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field set_findStaticField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
static Field set_findField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}
static String quoteIfNotIdentifierOrInteger(String s) {
if (s == null) return null;
return isJavaIdentifier(s) || isInteger(s) ? s : quote(s);
}
static TripleWeb ai_webToTripleWeb(Web web) {
T3 t = ai_webToTriple(web);
if (t == null) return null;
TripleWeb w = new TripleWeb();
w.a = t.a;
w.b = t.b;
w.c = t.c;
w.globalID(web.globalIDObj());
w.created = web.created;
w.source = web.source;
w.flags = web.unverified ? w.UNVERIFIED : 0;
if (eq(str(w.globalID()), "lvywpyszshojqpee"))
print("Have triple: " + sfu(w));
return w;
}
static String lispHead(Lisp l) {
return l == null ? null : l.head;
}
static void addAll(Collection c, Collection b) {
if (c != null && b != null) c.addAll(b);
}
static void addAll(Collection c, A... b) {
if (c != null) c.addAll(Arrays.asList(b));
}
static List ai_triplesToWebNodes_lazyList(final String searchTerm, final List l) {
return new LazyList() {
final int n = l(l);
public int size() { return n; }
public WebNode get(int i) {
TripleWeb w = l.get(i);
int runLength = 0;
while (i-runLength > 0 && l.get(i-runLength-1) == w)
++runLength;
return ai_tripleToWebNode(l.get(i), searchTerm, runLength);
}
};
}
static TripleWeb dummyTripleWebWithGlobalID(GlobalID id) {
TripleWeb w = new TripleWeb();
w.globalID(id);
return w;
}
static String webToStringShort(Web web) {
try {
if (web == null) return "-";
int n = l(web_nodes(web));
if (n == 0) return "Empty web";
WebNode a = web_firstNode(web);
if (n == 1) return join(" = ", web_texts(a));
if (n == 2) {
WebNode b = web_secondNode(web);
return ai_renderTriple(web_text(a), web_text(web_getRelation(a, b)), web_text(b));
}
return "Includes " + joinWithComma(map("web_text",web_nodes(web)));
} catch (Throwable e) { printException(e);
return "Error";
}
}
static String lisp2label(Lisp l) {
return l.isLeaf() ? l.head : clUnparse(l);
}
static List ll(A... a) {
ArrayList l = new ArrayList(a.length);
for (A x : a) l.add(x);
return l;
}
static List sortedInPlace(List l, final Object comparator) {
sort(l, makeComparator(comparator));
return l;
}
static List sortedInPlace(List l) {
sort(l);
return l;
}
static String webToString(Web web) {
List out = new ArrayList();
Map index = new HashMap();
for (int i = 0; i < l(web.nodes); i++) {
out.add("Node " + (i+1) + ": " + web.nodes.get(i));
index.put(web.nodes.get(i), i+1);
}
for (Pair p : web_relations(web))
out.add(index.get(p.a) + " -> " + index.get(p.b) + " = " + web.getRelation(p));
return fromLines(out);
}
static String div(Object contents, Object... params) {
return htag("div", contents, params);
}
static BigInteger div(BigInteger a, BigInteger b) {
return a.divide(b);
}
static BigInteger div(BigInteger a, int b) {
return a.divide(bigint(b));
}
static long nowUnlessLoading() {
return /*dynamicObjectIsLoading() ? 0 :*/ now();
}
static String find(String pattern, String text) {
Matcher matcher = Pattern.compile(pattern).matcher(text);
if (matcher.find())
return matcher.group(1);
return null;
}
static A find(Collection c, Object... data) {
for (A x : c)
if (checkFields(x, data))
return x;
return null;
}
static int indexOf(List l, A a, int startIndex) {
if (l == null) return -1;
for (int i = startIndex; i < l(l); i++)
if (eq(l.get(i), a))
return i;
return -1;
}
static int indexOf(List l, int startIndex, A a) {
return indexOf(l, a, startIndex);
}
static int indexOf(List l, A a) {
if (l == null) return -1;
return l.indexOf(a);
}
static int indexOf(String a, String b) {
return a == null || b == null ? -1 : a.indexOf(b);
}
static int indexOf(String a, String b, int i) {
return a == null || b == null ? -1 : a.indexOf(b, i);
}
static int indexOf(String a, char b) {
return a == null ? -1 : a.indexOf(b);
}
static int indexOf(String a, char b, int i) {
return a == null ? -1 : a.indexOf(b, i);
}
static int indexOf(String a, int i, String b) {
return a == null || b == null ? -1 : a.indexOf(b, i);
}
static int indexOf(A[] x, A a) {
if (x == null) return -1;
for (int i = 0; i < l(x); i++)
if (eq(x[i], a))
return i;
return -1;
}
static char charPlus(char a, int b) {
return (char) (((int) a) + b);
}
// make a lisp form
static Lisp lisp(String head, Object... args) {
Lisp l = new Lisp(head);
for (Object o : args)
l.add(o);
return l;
}
static Lisp lisp(String head, Collection args) {
return new Lisp(head, args);
}
static BigInteger plus(BigInteger a, BigInteger b) {
return a.add(b);
}
static BigInteger plus(BigInteger a, long b) {
return a.add(bigint(b));
}
static SyncListMultiMap caseInsensitiveSyncListMultiMap() {
SyncListMultiMap mm = new SyncListMultiMap();
mm.data = caseInsensitiveMap();
return mm;
}
static GlobalID aGlobalIDObj() {
return asGlobalID(randomID(16));
}
static List collect(Collection c, String field) {
return collectField(c, field);
}
static List collect(String field, Collection c) {
return collectField(c, field);
}
static List collect(Class c, String field) {
return collect(list(c), field);
}
static BigInteger mul(BigInteger a, BigInteger b) {
return a.multiply(b);
}
static BigInteger mul(BigInteger a, long b) {
return a.multiply(bigint(b));
}
static Set keys(Map map) {
return map == null ? new HashSet() : map.keySet();
}
static Set keys(Object map) {
return keys((Map) map);
}
static Set keys(MultiMap mm) {
return mm.keySet();
}
static void remove(List l, int i) {
if (l != null && i >= 0 && i < l(l))
l.remove(i);
}
static void remove(Collection l, A a) {
if (l != null) l.remove(a);
}
static int hashCode(Object a) {
return a == null ? 0 : a.hashCode();
}
static Map putAll(Map a, Map b) {
if (a != null) a.putAll(b);
return a;
}
static boolean setAdd(Collection c, A a) {
if (c == null || c.contains(a)) return false;
c.add(a);
return true;
}
static BigInteger bigint(String s) {
return new BigInteger(s);
}
static BigInteger bigint(long l) {
return BigInteger.valueOf(l);
}
static String unquote(String s) {
if (s == null) return null;
if (startsWith(s, '[')) {
int i = 1;
while (i < s.length() && s.charAt(i) == '=') ++i;
if (i < s.length() && s.charAt(i) == '[') {
String m = s.substring(1, i);
if (s.endsWith("]" + m + "]"))
return s.substring(i+1, s.length()-i-1);
}
}
if (s.length() > 1) {
char c = s.charAt(0);
if (c == '\"' || c == '\'') {
int l = endsWith(s, c) ? s.length()-1 : s.length();
StringBuilder sb = new StringBuilder(l-1);
for (int i = 1; i < l; i++) {
char ch = s.charAt(i);
if (ch == '\\') {
char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
// Octal escape?
if (nextChar >= '0' && nextChar <= '7') {
String code = "" + nextChar;
i++;
if ((i < l - 1) && s.charAt(i + 1) >= '0'
&& s.charAt(i + 1) <= '7') {
code += s.charAt(i + 1);
i++;
if ((i < l - 1) && s.charAt(i + 1) >= '0'
&& s.charAt(i + 1) <= '7') {
code += s.charAt(i + 1);
i++;
}
}
sb.append((char) Integer.parseInt(code, 8));
continue;
}
switch (nextChar) {
case '\"':
ch = '\"';
break;
case '\\':
ch = '\\';
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case 'n':
ch = '\n';
break;
case 'r':
ch = '\r';
break;
case 't':
ch = '\t';
break;
case '\'':
ch = '\'';
break;
// Hex Unicode: u????
case 'u':
if (i >= l - 5) {
ch = 'u';
break;
}
int code = Integer.parseInt(
"" + s.charAt(i + 2) + s.charAt(i + 3)
+ s.charAt(i + 4) + s.charAt(i + 5), 16);
sb.append(Character.toChars(code));
i += 5;
continue;
default:
ch = nextChar; // added by Stefan
}
i++;
}
sb.append(ch);
}
return sb.toString();
}
}
return s; // not quoted - return original
}
static String clUnparse(Lisp l) {
if (l == null) return "";
return join(" ", (List) concatLists(ll(conceptQuote(l.head)), map("clUnparse_sub", l)));
}
static String clUnparse_sub(Lisp l) {
return l.empty() ? clUnparse(l) : "(" + clUnparse(l) + ")";
}
static List clUnparse(List l) {
return map("clUnparse", l);
}
static String getString(Map map, Object key) {
return map == null ? null : (String) map.get(key);
}
static String getString(List l, int idx) {
return (String) get(l, idx);
}
static String getString(Object o, Object key) {
if (o instanceof Map) return getString((Map) o, key);
if (key instanceof String)
return (String) getOpt(o, (String) key);
throw fail("Not a string key: " + getClassName(key));
}
static boolean containsIgnoreCase(Collection l, String s) {
for (String x : l)
if (eqic(x, s))
return true;
return false;
}
static boolean containsIgnoreCase(String[] l, String s) {
for (String x : l)
if (eqic(x, s))
return true;
return false;
}
static boolean containsIgnoreCase(String s, char c) {
return indexOfIgnoreCase(s, String.valueOf(c)) >= 0;
}
static boolean containsIgnoreCase(String a, String b) {
return indexOfIgnoreCase(a, b) >= 0;
}
static Pair pair(A a, B b) {
return new Pair(a, b);
}
static Pair pair(A a) {
return new Pair(a, a);
}
static int charDiff(char a, char b) {
return (int) a-(int) b;
}
// optimistic signature that usually holds
static A clone(A o) {
ArrayDeque q = new ArrayDeque();
Object x = clone_impl(o, new IdentityHashMap(), q);
while (!q.isEmpty())
q.poll().run();
return (A) x;
}
static Object clone_impl(Object o, final IdentityHashMap seen, final ArrayDeque q) { try {
if (o == null) return null;
Object y = seen.get(o);
if (y != null) return y;
if (o instanceof List) {
//print("Cloning list: " + o);
final List l = new ArrayList();
seen.put(o, l);
for (final Object x : (List) o)
q.add(new Runnable() { public void run() { try { l.add(clone_impl(x, seen, q)) ;
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "l.add(clone_impl(x, seen, q))"; }});
return l;
}
if (o instanceof Map) {
final Map m = similarEmptyMap((Map) o);
seen.put(o, m);
for (Object entry : ((Map) o).entrySet()) {
final Map.Entry e = (Map.Entry) entry;
q.add(new Runnable() { public void run() { try {
m.put(clone_impl(e.getKey(), seen, q), clone_impl(e.getValue(), seen, q))
;
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "m.put(clone_impl(e.getKey(), seen, q), clone_impl(e.getValue(), seen, q))"; }});
}
return m;
}
if (o instanceof String || o instanceof Number || o instanceof Boolean) return o;
if (o instanceof Object[]) {
final Object[] l = (Object[]) o;
final Object[] l2 = l.clone();
seen.put(o, l2);
for (int i = 0; i < l.length; i++) {
final int _i = i;
q.add(new Runnable() { public void run() { try { l2[_i] = clone_impl(l[_i], seen, q) ;
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "l2[_i] = clone_impl(l[_i], seen, q)"; }});
}
return l2;
}
// clone an arbitrary custom object
//print("Cloning custom: " + o);
final Object clone = nuObjectWithoutArguments(o.getClass());
seen.put(o, clone);
Class c = o.getClass();
while (c != Object.class) {
Field[] fields = c.getDeclaredFields();
for (final Field field : fields) {
if ((field.getModifiers() & Modifier.STATIC) != 0)
continue;
field.setAccessible(true);
final Object value = field.get(o);
q.add(new Runnable() { public void run() { try { field.set(clone, clone_impl(value, seen, q)) ;
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "field.set(clone, clone_impl(value, seen, q))"; }});
}
c = c.getSuperclass();
}
return clone;
} catch (Exception __e) { throw rethrow(__e); } }
static int hashCodeFor(Object a) {
return a == null ? 0 : a.hashCode();
}
static String htag(String tag) {
return htag(tag, "");
}
static String htag(String tag, Object contents, Object... params) {
String openingTag = hopeningTag(tag, params);
String s = str(contents);
if (empty(s))
return dropLast(openingTag) + "/>";
return openingTag + s + "";
}
static String web_text(WebNode node) {
return node == null ? null : node.text();
}
static void ai_onNewWeb(Object onNewWeb) {
if (onNewWeb == null) return;
setAdd(postSoftwareMadeWeb_onNewWeb, onNewWeb);
onTransientWebAdded_do(onNewWeb);
}
static List onTransientWebRemoved_list = synchroList();
// f: voidfunc(Web)
static void onTransientWebRemoved_do(Object f) {
setAdd(onTransientWebRemoved_list, f);
}
static void onTransientWebRemoved(Web web) {
pcallFAll(onTransientWebRemoved_list, web);
}
static List dropFirstAndLast(int n, List l) {
return new ArrayList(subList(l, n, l(l)-n));
}
static String dropFirstAndLast(String s) {
return substring(s, 1, l(s)-1);
}
static List web_nodes(Web web) {
return web_nonRelationNodes(web);
}
static T3 ai_webToTriple(Web web) {
if (web == null) return null;
Collection l = web_relationObjects(web);
if (l(l) != 1) return null;
WebRelation r = first(l);
if (!web_tripelizableNode(r.a)
|| !web_tripelizableNode(r.b)
|| !web_tripelizableNode(r)) return null;
return t3(web_text(r.a), web_text(r), web_text(r.b));
}
static boolean endsWith(String a, String b) {
return a != null && a.endsWith(b);
}
static boolean endsWith(String a, char c) {
return nempty(a) && lastChar(a) == c;
}
static boolean endsWith(String a, String b, Matches m) {
if (!endsWith(a, b)) return false;
m.m = new String[] {dropLast(l(b), a)};
return true;
}
static String joinWithComma(Collection c) {
return join(", ", c);
}
static String joinWithComma(String... c) {
return join(", ", c);
}
static List web_texts(WebNode node) {
return node == null ? new ArrayList() : node.texts();
}
static List web_texts(Collection l) {
List texts = new ArrayList(l(l));
if (l != null) for (WebNode n : l)
texts.add(web_text(n));
return texts;
}
static List collectField(Collection c, String field) {
List l = new ArrayList();
for (Object a : c)
l.add(getOpt(a, field));
return l;
}
static WebRelation web_getRelation(WebNode a, WebNode b) {
return a.web.getRelation(a, b);
}
static Comparator makeComparator(final Object f) {
return new Comparator() {
public int compare(Object a, Object b) {
return (int) callF(f, a, b);
}
};
}
static boolean aiUsing_enabled;
static Set aiUsing_set = synchroTreeSet();
static String aiUsing(String s) {
if (aiUsing_enabled)
aiUsing_set.addAll(aggressivelyCollectPossibleGlobalIDs(s));
return s;
}
static void aiUsing(Object o) {
// TODO
}
static List aiUsing(List l) {
if (aiUsing_enabled)
for (Object li : unnull(l)) aiUsing(li);
return l;
}
static Lisp aiUsing(Lisp l) {
if (aiUsing_enabled && l != null) {
aiUsing(l.head);
for (Lisp sub : l) aiUsing(sub);
}
return l;
}
static Map nuObjectWithoutArguments_cache = newWeakHashMap();
static Object nuObjectWithoutArguments(String className) { try {
return nuObjectWithoutArguments(classForName(className));
} catch (Exception __e) { throw rethrow(__e); } }
static A nuObjectWithoutArguments(Class c) { try {
Constructor m;
m = nuObjectWithoutArguments_cache.get(c);
if (m == null)
nuObjectWithoutArguments_cache.put(c, m = nuObjectWithoutArguments_findConstructor(c));
return (A) m.newInstance();
} catch (Exception __e) { throw rethrow(__e); } }
static Constructor nuObjectWithoutArguments_findConstructor(Class c) {
for (Constructor m : c.getDeclaredConstructors())
if (empty(m.getParameterTypes())) {
m.setAccessible(true);
return m;
}
throw fail("No default constructor found in " + c.getName());
}
static GlobalID asGlobalID(String id) {
return id == null ? null : new GlobalID(id);
}
static String sfu(Object o) { return structureForUser(o); }
static Set> web_relations(Web web) {
LinkedHashSet < Pair < WebNode , WebNode > > l = new LinkedHashSet();
for (WebNode n : web.nodes)
if (n instanceof WebRelation)
l.add(pair(((WebRelation) n).a, ((WebRelation) n).b));
return l;
}
static String assertPossibleGlobalID(String s) {
if (!possibleGlobalID(s))
throw fail("Not an acceptable global ID: " + s);
return s;
}
static Map similarEmptyMap(Map m) {
if (m instanceof TreeMap) return new TreeMap();
if (m instanceof LinkedHashMap) return new LinkedHashMap();
// default to a hash map
return new HashMap();
}
static List tok_groupRoundBrackets(String s) {
List tok = javaTok(s);
while (true) {
int i = tok.lastIndexOf("(");
if (i < 0) return tok;
int j = indexOf(tok, ")", i);
if (j < 0) return tok;
tok.set(i, join(subList(tok, i, j+1)));
tok.subList(i+1, j+1).clear();
assertTrue(odd(l(tok)));
}
}
// usually L
static String fromLines(Collection lines) {
StringBuilder buf = new StringBuilder();
if (lines != null)
for (Object line : lines)
buf.append(str(line)).append('\n');
return buf.toString();
}
static String fromLines(String... lines) {
return fromLines(asList(lines));
}
static String ai_renderTriple(T3 t) {
return ai_tripleToString(t);
}
static String ai_renderTriple(String a, String b, String c) {
return ai_tripleToString(triple(a, b, c));
}
static long now_virtualTime;
static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
static boolean checkFields(Object x, Object... data) {
for (int i = 0; i < l(data); i += 2)
if (neq(getOpt(x, (String) data[i]), data[i+1]))
return false;
return true;
}
static String conceptQuote(String s) {
if (isIdentifier(s) || isInteger(s) || isProperlyQuoted(s)) return s;
return quote(s);
}
static boolean eqic(String a, String b) {
if ((a == null) != (b == null)) return false;
if (a == null) return true;
return a.equalsIgnoreCase(b);
}
static Object getOpt(Object o, String field) {
return getOpt_cached(o, field);
}
static Object getOpt_raw(Object o, String field) {
try {
Field f = getOpt_findField(o.getClass(), field);
if (f == null) return null;
f.setAccessible(true);
return f.get(o);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// access of static fields is not yet optimized
static Object getOpt(Class c, String field) {
try {
if (c == null) return null;
Field f = getOpt_findStaticField(c, field);
if (f == null) return null;
f.setAccessible(true);
return f.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field getOpt_findStaticField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static WebNode web_firstNode(Web web) {
return web == null ? null : first(web.nodes);
}
static Map litmap(Object... x) {
HashMap map = new HashMap();
litmap_impl(map, x);
return map;
}
static void litmap_impl(Map map, Object... x) {
for (int i = 0; i < x.length-1; i += 2)
if (x[i+1] != null)
map.put(x[i], x[i+1]);
}
static boolean isJavaIdentifier(String s) {
if (empty(s) || !Character.isJavaIdentifierStart(s.charAt(0)))
return false;
for (int i = 1; i < s.length(); i++)
if (!Character.isJavaIdentifierPart(s.charAt(i)))
return false;
return true;
}
static ArrayList litlist(A... a) {
ArrayList l = new ArrayList(a.length);
for (A x : a) l.add(x);
return l;
}
static List map(Iterable l, Object f) {
return map(f, l);
}
static List map(Object f, Iterable l) {
List x = emptyList(l);
if (l != null) for (Object o : l)
x.add(callF(f, o));
return x;
}
static List map(F1 f, Iterable l) {
List x = emptyList(l);
if (l != null) for (Object o : l)
x.add(callF(f, o));
return x;
}
static List map(Object f, Object[] l) { return map(f, asList(l)); }
static List map(Object[] l, Object f) { return map(f, l); }
static List map(Object f, Map map) {
return map(map, f);
}
// map: func(key, value) -> list element
static List map(Map map, Object f) {
List x = new ArrayList();
if (map != null) for (Object _e : map.entrySet()) {
Map.Entry e = (Map.Entry) _e;
x.add(callF(f, e.getKey(), e.getValue()));
}
return x;
}
static int max(int a, int b) { return Math.max(a, b); }
static int max(int a, int b, int c) { return max(max(a, b), c); }
static long max(int a, long b) { return Math.max((long) a, b); }
static long max(long a, long b) { return Math.max(a, b); }
static double max(int a, double b) { return Math.max((double) a, b); }
static float max(float a, float b) { return Math.max(a, b); }
static double max(double a, double b) { return Math.max(a, b); }
static int max(Collection c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
static double max(double[] c) {
if (c.length == 0) return Double.MIN_VALUE;
double x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static float max(float[] c) {
if (c.length == 0) return Float.MAX_VALUE;
float x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static byte max(byte[] c) {
byte x = -128;
for (byte d : c) if (d > x) x = d;
return x;
}
static short max(short[] c) {
short x = -0x8000;
for (short d : c) if (d > x) x = d;
return x;
}
// works on lists and strings and null
static int indexOfIgnoreCase(Object a, Object b) {
if (a == null) return -1;
if (a instanceof String) {
Matcher m = Pattern.compile((String) b, Pattern.CASE_INSENSITIVE + Pattern.LITERAL).matcher((String) a);
if (m.find()) return m.start(); else return -1;
}
if (a instanceof List) {
for (int i = 0; i < ((List) a).size(); i++) {
Object o = ((List) a).get(i);
if (o != null && ((String) o).equalsIgnoreCase((String) b))
return i;
}
return -1;
}
throw fail("Unknown type: " + a);
}
static WebNode web_secondNode(Web web) {
return web == null ? null : second(web.nodes);
}
static TreeMap caseInsensitiveMap() {
return new TreeMap(String.CASE_INSENSITIVE_ORDER);
}
static void sort(T[] a, Comparator c) {
Arrays.sort(a, c);
}
static void sort(T[] a) {
Arrays.sort(a);
}
static void sort(List a, Comparator c) {
Collections.sort(a, c);
}
static void sort(List a) {
Collections.sort(a);
}
static List concatLists(Collection... lists) {
List l = new ArrayList();
for (Collection list : lists)
if (list != null)
l.addAll(list);
return l;
}
static List concatLists(Collection> lists) {
List l = new ArrayList();
for (List list : lists)
if (list != null)
l.addAll(list);
return l;
}
static WebNode ai_tripleToWebNode(TripleWeb w, String searchTerm, int occurrence) {
if (w == null) return null;
print("ai_tripleToWebNode_debug: " + sfu(w) + ", searchTerm=" + quote(searchTerm) + ", occurrence=" + occurrence);
Web web = webFromTripleWeb(w);
try {
for (int i = 0; i < l(web.nodes); i++)
if (eqic(web_text(web.nodes.get(i)), searchTerm)) {
if (occurrence-- == 0) return web.nodes.get(i);
}
return null;
} catch (Throwable e) {
print("ai_tripleToWebNode: " + e + " " + sfu(w) + " => " + webToStringShort(web));
throw rethrow(e);
}
}
static Object callOpt(Object o) {
if (o == null) return null;
return callF(o);
}
static Object callOpt(Object o, String method, Object... args) {
try {
if (o == null) return null;
if (o instanceof Class) {
Method m = callOpt_findStaticMethod((Class) o, method, args, false);
if (m == null) return null;
m.setAccessible(true);
return m.invoke(null, args);
} else {
Method m = callOpt_findMethod(o, method, args, false);
if (m == null) return null;
m.setAccessible(true);
return m.invoke(o, args);
}
} catch (Exception e) {
//fail(e.getMessage() + " | Method: " + method + ", receiver: " + className(o) + ", args: (" + join(", ", map(f className, args) + ")");
throw new RuntimeException(e);
}
}
static Method callOpt_findStaticMethod(Class c, String method, Object[] args, boolean debug) {
Class _c = c;
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (!m.getName().equals(method)) {
if (debug) System.out.println("Method name mismatch: " + method);
continue;
}
if ((m.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0 || !callOpt_checkArgs(m, args, debug))
continue;
return m;
}
c = c.getSuperclass();
}
return null;
}
static Method callOpt_findMethod(Object o, String method, Object[] args, boolean debug) {
Class c = o.getClass();
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (m.getName().equals(method) && callOpt_checkArgs(m, args, debug))
return m;
}
c = c.getSuperclass();
}
return null;
}
private static boolean callOpt_checkArgs(Method m, Object[] args, boolean debug) {
Class[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static void smartSet(Field f, Object o, Object value) throws Exception {
f.setAccessible(true);
// take care of common case (long to int)
if (f.getType() == int.class && value instanceof Long)
value = ((Long) value).intValue();
try {
f.set(o, value);
} catch (Exception e) {
try {
if (f.getType() == Concept.Ref.class) {
f.set(o, ((Concept) o).new Ref((Concept) value));
return;
}
if (o instanceof Concept.Ref) {
f.set(o, ((Concept.Ref) o).get());
return;
}
} catch (Throwable _e) {}
throw e;
}
}
static int randomID_defaultLength = 12;
static String randomID(int length) {
return makeRandomID(length);
}
static String randomID() {
return randomID(randomID_defaultLength);
}
static String[] dropLast(String[] a, int n) {
n = Math.min(n, a.length);
String[] b = new String[a.length-n];
System.arraycopy(a, 0, b, 0, b.length);
return b;
}
static List dropLast(List l) {
return subList(l, 0, l(l)-1);
}
static List dropLast(int n, List l) {
return subList(l, 0, l(l)-n);
}
static List dropLast(Iterable l) {
return dropLast(asList(l));
}
static String dropLast(String s) {
return substring(s, 0, l(s)-1);
}
static String dropLast(String s, int n) {
return substring(s, 0, l(s)-n);
}
static String dropLast(int n, String s) {
return dropLast(s, n);
}
static List onTransientWebAdded_list = synchroList();
// f: voidfunc(Web)
static void onTransientWebAdded_do(Object f) {
setAdd(onTransientWebAdded_list, f);
}
static void onTransientWebAdded(Web web) {
pcallFAll(onTransientWebAdded_list, web);
}
static boolean isProperlyQuoted(String s) {
return s.length() >= 2
&& s.startsWith("\"")
&& s.endsWith("\"")
&& (!s.endsWith("\\\"") || s.endsWith("\\\\\""));
}
static T3 t3(A a, B b, C c) {
return new T3(a, b, c);
}
static Set synchroTreeSet() {
return Collections.synchronizedSet(new TreeSet());
}
static ThreadLocal postSoftwareMadeWeb_disabled = new ThreadLocal();
static BetterThreadLocal postSoftwareMadeWeb_websMadeInThread = new BetterThreadLocal();
static ThreadLocal postSoftwareMadeWeb_maker = new ThreadLocal();
// L
// function can also return false to stop triggerWebsChanged
static List postSoftwareMadeWeb_onNewWeb = synchroList();
// L