/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.cas.impl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.Vector;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.CASException;
import org.apache.uima.cas.CASRuntimeException;
import org.apache.uima.cas.FSIndex;
import org.apache.uima.cas.FSIterator;
import org.apache.uima.cas.FeatureStructure;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.TypeSystem;
import org.apache.uima.cas.admin.CASAdminException;
import org.apache.uima.cas.admin.FSIndexComparator;
import org.apache.uima.cas.admin.FSIndexRepositoryMgr;
import org.apache.uima.cas.admin.LinearTypeOrder;
import org.apache.uima.cas.admin.LinearTypeOrderBuilder;
import org.apache.uima.internal.util.ComparableIntPointerIterator;
import org.apache.uima.internal.util.IntComparator;
import org.apache.uima.internal.util.IntPointerIterator;
import org.apache.uima.internal.util.IntVector;
import org.apache.uima.internal.util.SortedIntSet;
public class FSIndexRepositoryImpl implements FSIndexRepositoryMgr, LowLevelIndexRepository {
// Implementation note: the use of equals() here is pretty hairy and
// should probably be fixed. We rely on the fact that when two
// FSIndexComparators are compared, the type of the comparators is
// ignored! A fix for this would be to split the FSIndexComparator
// class into two classes, one for the key-comparator pairs, and one
// for the combination of the two. Note also that we compare two
// IndexIteratorCachePairs by comparing their
// index.getComparator()s.
/**
* A pair of an index and an iterator cache. An iterator cache is the set of all indexes necessary
* to create an iterator for the type of the index. compareTo() is based on types and the
* comparator of the index.
*/
private class IndexIteratorCachePair implements Comparable {
// The "root" index, i.e., index of the type of the iterator.
private FSLeafIndexImpl index = null;
// A list of indexes (the sub-indexes that we need for an
// iterator). I.e., one index for each type that's subsumed by the
// iterator
// type.
private ArrayList iteratorCache = null;
private IndexIteratorCachePair() {
super();
}
// Two IICPs are equal iff their index comparators are equal AND their
// indexing strategy is the same.
public boolean equals(Object o) {
if (!(o instanceof IndexIteratorCachePair)) {
return false;
}
final IndexIteratorCachePair iicp = (IndexIteratorCachePair) o;
return this.index.getComparator().equals(iicp.index.getComparator())
&& (this.index.getIndexingStrategy() == iicp.index.getIndexingStrategy());
}
public int hashCode() {
throw new UnsupportedOperationException();
}
// Populate the cache.
private void createIndexIteratorCache() {
if (this.iteratorCache != null) {
return;
}
this.iteratorCache = new ArrayList();
final Type rootType = this.index.getComparator().getType();
ArrayList allTypes = null;
if (this.index.getIndexingStrategy() == FSIndex.DEFAULT_BAG_INDEX) {
allTypes = new ArrayList();
allTypes.add(rootType);
} else {
allTypes = getAllSubsumedTypes(rootType, FSIndexRepositoryImpl.this.typeSystem);
}
final int len = allTypes.size();
int typeCode, indexPos;
ArrayList indexList;
for (int i = 0; i < len; i++) {
typeCode = ((TypeImpl) allTypes.get(i)).getCode();
indexList = FSIndexRepositoryImpl.this.indexArray[typeCode];
indexPos = indexList.indexOf(this);
if (indexPos >= 0) {
this.iteratorCache.add(((IndexIteratorCachePair) indexList.get(indexPos)).index);
}
}
}
/**
* @see java.lang.Comparable#compareTo(Object)
*/
public int compareTo(Object o) {
IndexIteratorCachePair cp = (IndexIteratorCachePair) o;
final int typeCode1 = ((TypeImpl) this.index.getType()).getCode();
final int typeCode2 = ((TypeImpl) cp.index.getType()).getCode();
if (typeCode1 < typeCode2) {
return -1;
} else if (typeCode1 > typeCode2) {
return 1;
} else { // types are equal
return this.index.getComparator().compareTo(cp.index.getComparator());
}
}
int size() {
int size = 0;
for (int i = 0; i < this.iteratorCache.size(); i++) {
size += ((LowLevelIndex) this.iteratorCache.get(i)).size();
}
return size;
}
}
/**
* Comparator wrapper; will used wrapped comparator, and on equality use address of FS for further
* distinction.
*/
private static class IteratorComparator implements IntComparator {
private final IntComparator comp;
private IteratorComparator(IntComparator comp) {
super();
this.comp = comp;
}
/**
* @see org.apache.uima.internal.util.IntComparator#compare(int, int)
*/
public int compare(int i, int j) {
final int compResult = this.comp.compare(i, j);
if (compResult == 0) {
if (i < j) {
return -1;
} else if (i > j) {
return 1;
}
}
return compResult;
}
}
/**
* The iterator implementation for indexes. Tricky because the iterator needs to be able to move
* backwards as well as forwards.
*/
private class PointerIterator implements IntPointerIterator, LowLevelIterator {
// The IICP
private IndexIteratorCachePair iicp;
// An array of integer arrays, one for each subtype.
private ComparableIntPointerIterator[] indexes;
// snapshot to detectIllegalIndexUpdates
// need to move this to ComparableIntPointerIterator so it can be tested
// Size of index (iterator) array.
private int indexesSize;
// The number of currently active indexes (some may be invalid).
private int numIndexes;
// The current index, i.e., the index that contains the current element.
private int currentIndex;
// Remember the direction of the previous move, so we can save ourselves
// some work.
private boolean wentForward;
// Comparator that is used to compare FS addresses for the purposes of
// iteration. If two FSs are identical wrt the comparator of the index,
// we still need to be able to distinguish them to be able to have a
// well-defined sequence. In that case, we arbitrarily order FSs by
// their
// addresses. We need to do this in order to be able to ensure that a
// reverse iterator produces the reverse order of the forward iterator.
private IntComparator iteratorComparator;
// The next element in the iterator. When next < 0, there is no
// next.
// private int next;
private PointerIterator() {
super();
}
private void initPointerIterator(IndexIteratorCachePair iicp0) {
this.iicp = iicp0;
// Make sure the iterator cache exists.
iicp0.createIndexIteratorCache();
ArrayList iteratorCache = iicp0.iteratorCache;
this.indexesSize = iteratorCache.size();
this.indexes = new ComparableIntPointerIterator[this.indexesSize];
this.numIndexes = this.indexesSize;
this.iteratorComparator = new IteratorComparator((FSLeafIndexImpl) iteratorCache.get(0));
ComparableIntPointerIterator it;
for (int i = 0; i < this.indexesSize; i++) {
final FSLeafIndexImpl leafIndex = ((FSLeafIndexImpl) iteratorCache.get(i));
it = leafIndex.pointerIterator(this.iteratorComparator,
FSIndexRepositoryImpl.this.detectIllegalIndexUpdates, ((TypeImpl) leafIndex.getType())
.getCode());
this.indexes[i] = it;
}
}
private PointerIterator(IndexIteratorCachePair iicp) {
super();
initPointerIterator(iicp);
moveToFirst();
}
private PointerIterator(IndexIteratorCachePair iicp, int fs) {
super();
initPointerIterator(iicp);
moveTo(fs);
}
public boolean isValid() {
// We're valid as long as at least one index is.
return (this.numIndexes > 0);
}
private ComparableIntPointerIterator checkConcurrentModification(int i) {
ComparableIntPointerIterator cipi = this.indexes[i];
if (cipi.isConcurrentModification())
throw new ConcurrentModificationException();
return cipi;
}
private void resetConcurrentModification(int i) {
ComparableIntPointerIterator cipi = this.indexes[i];
cipi.resetConcurrentModification();
}
private void checkConcurrentModificationAll() {
for (int i = 0; i < this.indexes.length; i++) {
checkConcurrentModification(i);
}
}
public void moveToFirst() {
for (int i = 0; i < this.indexes.length; i++) {
resetConcurrentModification(i);
this.indexes[i].moveToFirst();
}
this.numIndexes = this.indexes.length;
checkIndexesTo(this.numIndexes);
// bubbleSort(indexes, numIndexes);
Arrays.sort(this.indexes, 0, this.numIndexes);
this.wentForward = true;
return;
}
public void moveToLast() {
for (int i = 0; i < this.indexes.length; i++) {
resetConcurrentModification(i);
this.indexes[i].moveToLast();
}
this.numIndexes = this.indexes.length;
checkIndexesTo(this.numIndexes);
// bubbleSort(indexes, numIndexes);
Arrays.sort(this.indexes, 0, this.numIndexes);
this.currentIndex = (this.numIndexes - 1);
this.wentForward = false;
return;
}
public void moveToNext() {
// If we're not valid, return.
if (!isValid()) {
return;
}
checkConcurrentModificationAll();
// Increment iterators, taking into account which direction the last
// move
// was in.
boolean tempWentForward = this.wentForward;
incrementIterators();
// If we're not valid, return.
if (!isValid()) {
return;
}
// The individual iterators are pointing at the correct elements,
// and
// we can simply sort them to find the next one.
// bubbleSort(indexes, numIndexes);
// Arrays.sort(indexes, 0, numIndexes);
if (tempWentForward) {
insert(0, this.indexes, this.numIndexes);
} else {
Arrays.sort(this.indexes, 0, this.numIndexes);
}
// Moving up, the smallest element is the next one to show.
this.currentIndex = 0;
return;
}
private final void insert(int pos, Comparable[] array, int size) {
final int max = size - 1;
int comp, next;
Comparable tmp;
while (pos < max) {
next = pos + 1;
comp = array[pos].compareTo(array[next]);
if (comp <= 0) {
return;
}
tmp = array[pos];
array[pos] = array[next];
array[next] = tmp;
++pos;
}
}
private void ensureIndexValidity(int index) {
// assert(index >= 0);
// assert(index < numIndexes);
if (!this.indexes[index].isValid()) {
// If the index is not valid, we throw it out.
if ((index + 1) == this.numIndexes) {
// If the index was the last index in the array, we just
// shrink the
// array.
--this.numIndexes;
} else {
// Else we shrink the array and swap the previously last
// element to
// the position where we want to delete the index.
--this.numIndexes;
ComparableIntPointerIterator tempIt = this.indexes[index];
this.indexes[index] = this.indexes[this.numIndexes];
this.indexes[this.numIndexes] = tempIt;
}
}
}
private void checkIndexesTo(int max) {
// Because of the way checkIndexValidity() works, we need to work
// back
// to front.
for (int i = (max - 1); i >= 0; i--) {
ensureIndexValidity(i);
}
}
private void incrementIterators() {
if (this.wentForward) {
// This is the easy case. We just need to increment the current
// index.
this.indexes[this.currentIndex].inc();
// Make sure it's still valid.
ensureIndexValidity(this.currentIndex);
} else {
// Else we need to increment everything, including the currently
// inactive indexes!
ComparableIntPointerIterator it;
for (int i = 0; i < this.indexesSize; i++) {
// Any iterator other than the current one needs to be
// incremented
// until it's pointing at something that's greater than the
// current
// element.
if (i != this.currentIndex) {
it = this.indexes[i];
// If the iterator we're considering is not valid, we
// set it to the
// first element. This should be it for this iterator...
if (!it.isValid()) {
it.moveToFirst();
}
// while (it.isValid() &&
// (it.compareTo(indexes[this.currentIndex]) < 0)) {
// Increment the iterator while it is valid and pointing
// at something
// smaller than the current element.
while (it.isValid()
&& (this.iteratorComparator
.compare(it.get(), this.indexes[this.currentIndex].get()) < 0)) {
it.inc();
}
}
}
// Increment the current index.
this.indexes[this.currentIndex].inc();
// Set number of this.indexes to all indexes.
this.numIndexes = this.indexesSize;
// Ensure validity of all active iterators.
checkIndexesTo(this.numIndexes);
}
this.wentForward = true;
}
public void moveToPrevious() {
// If we're not valid, return.
if (!isValid()) {
return;
}
checkConcurrentModificationAll();
// Decrement iterators, taking into account which direction the last
// move
// was in.
decrementIterators();
// If we're not valid, return.
if (!isValid()) {
return;
}
// bubbleSort(indexes, this.numIndexes);
Arrays.sort(this.indexes, 0, this.numIndexes);
this.currentIndex = (this.numIndexes - 1);
return;
}
private void decrementIterators() {
// Note: this does not sort the iterators.
if (!this.wentForward) {
// This is the easy case. We just need to decrement the current
// index.
this.indexes[this.currentIndex].dec();
ensureIndexValidity(this.currentIndex);
} else {
// Else the current index is fine, but we have to decrement all
// indexes.
ComparableIntPointerIterator it;
for (int i = 0; i < this.indexesSize; i++) {
if (i != this.currentIndex) {
it = this.indexes[i];
// while (it.isValid() &&
// (it.compareTo(indexes[this.currentIndex]) > 0)) {
if (!it.isValid()) {
it.moveToLast();
}
while (it.isValid()
&& (this.iteratorComparator
.compare(it.get(), this.indexes[this.currentIndex].get()) > 0)) {
it.dec();
}
}
}
this.indexes[this.currentIndex].dec();
this.numIndexes = this.indexesSize;
checkIndexesTo(this.numIndexes);
}
this.wentForward = false;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.cas.impl.LowLevelIterator#ll_get()
*/
public int get() throws NoSuchElementException {
return ll_get();
}
public int ll_get() {
if (!isValid()) {
throw new NoSuchElementException();
}
return checkConcurrentModification(this.currentIndex).get();
}
public Object copy() {
// If this.isValid(), return a copy pointing to the same element.
if (this.isValid()) {
return new PointerIterator(this.iicp, this.get());
}
// Else, create a copy that is also not valid.
PointerIterator pi = new PointerIterator(this.iicp);
pi.moveToFirst();
pi.moveToPrevious();
return pi;
}
/**
* @see org.apache.uima.internal.util.IntPointerIterator#moveTo(int)
*/
public void moveTo(int fs) {
// Need to consider all iterators.
this.numIndexes = this.indexes.length;
// Set all iterators to insertion point.
for (int i = 0; i < this.numIndexes; i++) {
resetConcurrentModification(i);
this.indexes[i].moveTo(fs);
}
// Check validity of all indexes.
checkIndexesTo(this.numIndexes);
// Sort the valid indexes.
if (this.numIndexes > 1) {
Arrays.sort(this.indexes, 0, this.numIndexes);
}
// bubbleSort(indexes, numIndexes);
// The way we compute the insertion point, we're look forward.
this.wentForward = true;
this.currentIndex = 0;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.cas.impl.LowLevelIterator#moveToNext()
*/
public void inc() {
moveToNext();
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.cas.impl.LowLevelIterator#moveToPrevious()
*/
public void dec() {
moveToPrevious();
}
public int ll_indexSize() {
return this.iicp.size();
}
public LowLevelIndex ll_getIndex() {
return this.iicp.index;
}
}
private class IndexImpl implements FSIndex, FSIndexImpl {
private IndexIteratorCachePair iicp;
private IndexImpl(IndexIteratorCachePair iicp) {
super();
this.iicp = iicp;
}
public int ll_compare(int ref1, int ref2) {
return this.iicp.index.ll_compare(ref1, ref2);
}
public int getIndexingStrategy() {
return this.iicp.index.getIndexingStrategy();
}
public FSIndexComparator getComparator() {
return this.iicp.index.getComparator();
}
protected IntComparator getIntComparator() {
return this.iicp.index.getIntComparator();
}
public void flush() {
this.iicp.index.flush();
}
/**
* @see org.apache.uima.cas.FSIndex#compare(FeatureStructure, FeatureStructure)
*/
public int compare(FeatureStructure fs1, FeatureStructure fs2) {
return this.iicp.index.compare(fs1, fs2);
}
/**
* @see org.apache.uima.cas.FSIndex#contains(FeatureStructure)
*/
public boolean contains(FeatureStructure fs) {
return this.iicp.index.contains(fs);
}
public FeatureStructure find(FeatureStructure fs) {
return this.iicp.index.find(fs);
}
/**
* @see org.apache.uima.cas.FSIndex#getType()
*/
public Type getType() {
return this.iicp.index.getType();
}
/**
* @see org.apache.uima.cas.FSIndex#iterator()
*/
public FSIterator iterator() {
return new FSIteratorWrapper(new PointerIterator(this.iicp), FSIndexRepositoryImpl.this.cas);
}
/**
* @see org.apache.uima.cas.FSIndex#iterator(FeatureStructure)
*/
public FSIterator iterator(FeatureStructure fs) {
return new FSIteratorWrapper(new PointerIterator(this.iicp, ((FeatureStructureImpl) fs)
.getAddress()), FSIndexRepositoryImpl.this.cas);
}
public IntPointerIterator getIntIterator() {
return new PointerIterator(this.iicp);
}
/**
* @see org.apache.uima.cas.FSIndex#size()
*/
public int size() {
this.iicp.createIndexIteratorCache();
// int size = this.iicp.index.size();
int size = 0;
final ArrayList subIndex = this.iicp.iteratorCache;
final int max = subIndex.size();
for (int i = 0; i < max; i++) {
size += ((FSIndex) subIndex.get(i)).size();
}
return size;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.cas.impl.LowLevelIndex#ll_iterator()
*/
public LowLevelIterator ll_iterator() {
return new PointerIterator(this.iicp);
}
public LowLevelIterator ll_iterator(boolean ambiguous) {
if (ambiguous) {
return this.ll_iterator();
}
return new LLUnambiguousIteratorImpl(this.ll_iterator(), this.iicp.index.lowLevelCAS);
}
}
// private class AnnotIndexImpl
// extends IndexImpl
// implements AnnotationIndex, FSIndexImpl {
//
// private AnnotIndexImpl(IndexIteratorCachePair iicp) {
// super(iicp);
// }
//
// public FSIterator subiterator(AnnotationFS annot) {
// return new Subiterator(
// this.getIntIterator(),
// annot,
// (CASImpl) FSIndexRepositoryImpl.this.cas,
// this.getIntComparator());
// }
//
// public FSIterator subiterator(AnnotationFS annot, boolean ambiguous) {
// if (ambiguous) {
// return subiterator(annot);
// } else {
// return new UnambiguousIterator(subiterator(annot), this);
// }
// }
//
// public FSIterator unambigousIterator() {
// return new UnambiguousIterator(iterator(), this);
// }
//
// }
/**
* The default size of an index.
*/
public static final int DEFAULT_INDEX_SIZE = 100;
// A reference to the CAS.
private CASImpl cas;
// A reference to the type system.
private TypeSystemImpl typeSystem;
// Is the index repository locked?
private boolean locked = false;
// An array of ArrayLists, one for each type in the type hierarchy.
// The ArrayLists are unordered lists of IndexIteratorCachePairs for
// that type.
private ArrayList[] indexArray;
// an array of ints, one for each type in the type hierarchy.
// Used to enable iterators to detect modifications (adds / removes)
// to indexes they're iterating over while they're iterating over them.
// not private so it can be seen by FSLeafIndexImpl
int[] detectIllegalIndexUpdates;
// A map from names to IndexIteratorCachePairs. Different names may map to
// the same index.
private HashMap name2indexMap;
private LinearTypeOrderBuilder defaultOrderBuilder = null;
private LinearTypeOrder defaultTypeOrder = null;
private FSIndexRepositoryImpl() {
super();
}
/**
* Constructor.
*
* @param cas
*/
FSIndexRepositoryImpl(CASImpl cas) {
super();
this.cas = cas;
this.typeSystem = cas.getTypeSystemImpl();
this.name2indexMap = new HashMap();
init();
}
/**
* Constructor for views.
*
* @param cas
* @param baseIndexRepository
*/
FSIndexRepositoryImpl(CASImpl cas, FSIndexRepositoryImpl baseIndexRepo) {
super();
this.cas = cas;
this.typeSystem = cas.getTypeSystemImpl();
this.name2indexMap = new HashMap();
init();
Set keys = baseIndexRepo.name2indexMap.keySet();
if (!keys.isEmpty()) {
Iterator keysIter = keys.iterator();
while (keysIter.hasNext()) {
String key = (String) keysIter.next();
IndexIteratorCachePair iicp = (IndexIteratorCachePair) baseIndexRepo.name2indexMap.get(key);
createIndexNoQuestionsAsked(iicp.index.getComparator(), key, iicp.index
.getIndexingStrategy());
}
}
this.defaultOrderBuilder = baseIndexRepo.defaultOrderBuilder;
this.defaultTypeOrder = baseIndexRepo.defaultTypeOrder;
}
/**
* Initialize data. Called from the constructor.
*/
private void init() {
TypeSystemImpl ts = this.typeSystem;
// Type counting starts at 1.
final int numTypes = ts.getNumberOfTypes() + 1;
this.indexArray = new ArrayList[numTypes];
for (int i = 1; i < numTypes; i++) {
this.indexArray[i] = new ArrayList();
}
this.detectIllegalIndexUpdates = new int[numTypes];
for (int i = 0; i < this.detectIllegalIndexUpdates.length; i++) {
this.detectIllegalIndexUpdates[i] = Integer.MIN_VALUE;
}
}
/**
* Reset all indexes.
*/
public void flush() {
if (!this.locked) {
return;
}
int max;
ArrayList v;
// The first element is null. This is not good...
for (int i = 1; i < this.indexArray.length; i++) {
v = this.indexArray[i];
max = v.size();
for (int j = 0; j < max; j++) {
((IndexIteratorCachePair) v.get(j)).index.flush();
}
}
}
public void addFS(int fsRef) {
ll_addFS(fsRef);
}
private IndexIteratorCachePair addNewIndex(FSIndexComparator comparator, int indexType) {
return addNewIndex(comparator, DEFAULT_INDEX_SIZE, indexType);
}
/**
* This is where the actual index gets created.
*/
private IndexIteratorCachePair addNewIndex(FSIndexComparator comparator, int initialSize,
int indexType) {
final Type type = comparator.getType();
final int typeCode = ((TypeImpl) type).getCode();
if (typeCode >= this.indexArray.length) {
// assert(false);
}
final ArrayList indexVector = this.indexArray[typeCode];
// final int vecLen = indexVector.size();
FSLeafIndexImpl ind;
switch (indexType) {
case FSIndex.SET_INDEX: {
ind = new FSRBTSetIndex(this.cas, type, indexType);
break;
}
case FSIndex.BAG_INDEX: {
ind = new FSBagIndex(this.cas, type, initialSize, indexType);
break;
}
case FSIndex.DEFAULT_BAG_INDEX: {
ind = new FSBagIndex(this.cas, type, initialSize, indexType);
break;
}
default: {
// SORTED_INDEX is the default. We don't throw any errors, if the
// code
// is unknown, we just create a sorted index (with duplicates).
// ind = new FSRBTIndex(this.cas, type, FSIndex.SORTED_INDEX);
ind = new FSIntArrayIndex(this.cas, type, initialSize, FSIndex.SORTED_INDEX);
break;
}
}
// ind = new FSRBTIndex(this.cas, type);
// ind = new FSVectorIndex(this.cas, initialSize);
ind.init(comparator);
IndexIteratorCachePair iicp = new IndexIteratorCachePair();
iicp.index = ind;
indexVector.add(iicp);
return iicp;
}
/*
* private IndexIteratorCachePair addIndex( FSIndexComparator comparator, int initialSize) { final
* Type type = comparator.getType(); final int typeCode = ((TypeImpl) type).getCode(); final
* Vector indexVector = this.indexArray[typeCode]; final int vecLen = indexVector.size();
* FSLeafIndexImpl ind;
*
* for (int i = 0; i < vecLen; i++) { ind = ((IndexIteratorCachePair) indexVector.get(i)).index;
* if (comparator.equals(ind.getComparator())) { return null; } }
*
* ind = new FSRBTIndex(this.cas, type); // ind = new FSVectorIndex(this.cas, initialSize);
* ind.init(comparator); IndexIteratorCachePair iicp = new IndexIteratorCachePair(); iicp.index =
* ind; indexVector.add(iicp); return iicp; }
*/
// private IndexIteratorCachePair addIndexRecursive(FSIndexComparator
// comparator) {
// final FSIndexComparatorImpl compCopy =
// ((FSIndexComparatorImpl) comparator).copy();
// return addIndexRec(compCopy);
// }
private IndexIteratorCachePair addNewIndexRecursive(FSIndexComparator comparator, int indexType) {
final FSIndexComparatorImpl compCopy = ((FSIndexComparatorImpl) comparator).copy();
return addNewIndexRec(compCopy, indexType);
}
private static final int findIndex(ArrayList indexes, FSIndexComparator comp) {
FSIndexComparator indexComp;
final int max = indexes.size();
for (int i = 0; i < max; i++) {
indexComp = ((IndexIteratorCachePair) indexes.get(i)).index.getComparator();
if (comp.equals(indexComp)) {
return i;
}
}
return -1;
}
/*
* // Will modify comparator, so call with copy. private IndexIteratorCachePair
* addIndexRec(FSIndexComparator comp) { FSIndexComparator compCopy; IndexIteratorCachePair cp =
* this.addIndex(comp); if (cp == null) { return null; // The index already exists. } final Type
* superType = comp.getType(); final Vector types =
* this.typeSystem.getDirectlySubsumedTypes(superType); final int max = types.size(); for (int i =
* 0; i < max; i++) { compCopy = ((FSIndexComparatorImpl)comp).copy(); compCopy.setType((Type)
* types.get(i)); addIndexRec(compCopy); } return cp; }
*/
// Will modify comparator, so call with copy.
private IndexIteratorCachePair addNewIndexRec(FSIndexComparator comparator, int indexType) {
IndexIteratorCachePair iicp = this.addNewIndex(comparator, indexType);
if (indexType == FSIndex.DEFAULT_BAG_INDEX) {
// In this special case, we do not add indeces for subtypes.
return iicp;
}
final Type superType = comparator.getType();
final Vector types = this.typeSystem.getDirectlySubsumedTypes(superType);
final int max = types.size();
FSIndexComparator compCopy;
for (int i = 0; i < max; i++) {
compCopy = ((FSIndexComparatorImpl) comparator).copy();
compCopy.setType((Type) types.get(i));
addNewIndexRec(compCopy, indexType);
}
return iicp;
}
private static final ArrayList getAllSubsumedTypes(Type t, TypeSystem ts) {
ArrayList v = new ArrayList();
addAllSubsumedTypes(t, ts, v);
return v;
}
private static final void addAllSubsumedTypes(Type t, TypeSystem ts, ArrayList v) {
v.add(t);
List sub = ts.getDirectSubtypes(t);
final int len = sub.size();
for (int i = 0; i < len; i++) {
addAllSubsumedTypes((Type) sub.get(i), ts, v);
}
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#commit()
*/
public void commit() {
// Will create the default type order if it doesn't exist at this point.
getDefaultTypeOrder();
this.locked = true;
}
public LinearTypeOrder getDefaultTypeOrder() {
if (this.defaultTypeOrder == null) {
if (this.defaultOrderBuilder == null) {
this.defaultOrderBuilder = new LinearTypeOrderBuilderImpl(this.typeSystem);
}
try {
this.defaultTypeOrder = this.defaultOrderBuilder.getOrder();
} catch (CASException e) {
// Since we're doing this on an existing type names, we can't
// get here.
}
}
return this.defaultTypeOrder;
}
public LinearTypeOrderBuilder getDefaultOrderBuilder() {
if (this.defaultOrderBuilder == null) {
this.defaultOrderBuilder = new LinearTypeOrderBuilderImpl(this.typeSystem);
}
return this.defaultOrderBuilder;
}
void setDefaultTypeOrder(LinearTypeOrder order) {
this.defaultTypeOrder = order;
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#createIndex(FSIndexComparator, String)
*/
public boolean createIndex(FSIndexComparator comp, String label, int indexType)
throws CASAdminException {
if (this.locked) {
throw new CASAdminException(CASAdminException.REPOSITORY_LOCKED);
}
return createIndexNoQuestionsAsked(comp, label, indexType);
}
/**
* This is public only until the xml specifier format supports specifying index kinds (set, bag
* etc.).
*
* @param comp
* @param label
* @param indexType
* @return boolean
*/
public boolean createIndexNoQuestionsAsked(FSIndexComparator comp, String label, int indexType) {
IndexIteratorCachePair cp = (IndexIteratorCachePair) this.name2indexMap.get(label);
// Now check if the index already exists.
if (cp == null) {
// The name is new.
cp = this.addNewIndexRecursive(comp, indexType);
this.name2indexMap.put(label, cp);
return true;
}
// For now, just return false if the label already exists.
return false;
// // An index has previously been registered for this name. We need to
// // compare the types to see if the new addition is compatible with
// the
// // pre-existing one. There are three cases: the new type can be a
// sub-type
// // of the old one, in which case we don't need to do anything; or,
// the
// // new type is a super-type of the old one, in which case we add the
// new
// // index while keeping the old one; or, there is no subsumption
// relation,
// // in which case we can't add the index.
// Type oldType = cp.index.getType(); // Get old type from the index.
// Type newType = comp.getType(); // Get new type from comparator.
// if (this.typeSystem.subsumes(oldType, newType)) {
// // We don't need to do anything.
// return true;
// } else if (this.typeSystem.subsumes(newType, oldType)) {
// // Add the index, subsuming the old one.
// cp = this.addIndexRecursive(comp);
// // Replace the old index with the new one in the map.
// this.name2indexMap.put(label, cp);
// return true;
// } else {
// // Can't add index under that name.
// return false;
// }
// }
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#getIndexes()
*/
public Iterator getIndexes() {
ArrayList indexList = new ArrayList();
Iterator it = this.getLabels();
String label;
while (it.hasNext()) {
label = (String) it.next();
indexList.add(getIndex(label));
}
return indexList.iterator();
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#getLabels()
*/
public Iterator getLabels() {
return this.name2indexMap.keySet().iterator();
}
/**
* Get the labels for a specific comparator.
*
* @param comp
* The comparator.
* @return An iterator over the labels.
*/
public Iterator getLabels(FSIndexComparator comp) {
final ArrayList labels = new ArrayList();
Iterator it = this.getLabels();
String label;
while (it.hasNext()) {
label = (String) it.next();
if (((IndexIteratorCachePair) this.name2indexMap.get(label)).index.getComparator().equals(
comp)) {
labels.add(label);
}
}
return labels.iterator();
}
/**
* @see org.apache.uima.cas.FSIndexRepository#getIndex(String, Type)
*/
public FSIndex getIndex(String label, Type type) {
IndexIteratorCachePair iicp = (IndexIteratorCachePair) this.name2indexMap.get(label);
if (iicp == null) {
return null;
}
// Why is this necessary?
if (type.isArray()) {
Type componentType = type.getComponentType();
if (componentType != null && !componentType.isPrimitive()
&& !componentType.getName().equals(CAS.TYPE_NAME_TOP)) {
return null;
}
}
Type indexType = iicp.index.getType();
if (!this.typeSystem.subsumes(indexType, type)) {
CASRuntimeException cre = new CASRuntimeException(CASRuntimeException.TYPE_NOT_IN_INDEX,
new String[] { label, type.getName(), indexType.getName() });
throw cre;
}
final int typeCode = ((TypeImpl) type).getCode();
ArrayList inds = this.indexArray[typeCode];
// Since we found an index for the correct type, find() must return a
// valid result -- unless this is a special auto-index.
final int indexCode = findIndex(inds, iicp.index.getComparator());
if (indexCode < 0) {
return null;
}
// assert((indexCode >= 0) && (indexCode < inds.size()));
return new IndexImpl((IndexIteratorCachePair) inds.get(indexCode));
// return ((IndexIteratorCachePair)inds.get(indexCode)).index;
}
/**
* @see org.apache.uima.cas.FSIndexRepository#getIndex(String)
*/
public FSIndex getIndex(String label) {
IndexIteratorCachePair iicp = (IndexIteratorCachePair) this.name2indexMap.get(label);
if (iicp == null) {
return null;
}
return new IndexImpl(iicp);
// return ((IndexIteratorCachePair)name2indexMap.get(label)).index;
}
public IntPointerIterator getIntIteratorForIndex(String label) {
IndexImpl index = (IndexImpl) getIndex(label);
if (index == null) {
return null;
}
return new PointerIterator(index.iicp);
}
public IntPointerIterator getIntIteratorForIndex(String label, Type type) {
IndexImpl index = (IndexImpl) getIndex(label, type);
if (index == null) {
return null;
}
return new PointerIterator(index.iicp);
}
/**
*/
public int getIndexSize(Type type) {
final int typeCode = ((TypeImpl) type).getCode();
final ArrayList indexVector = this.indexArray[typeCode];
if (indexVector.size() == 0) {
// No index for this type exists.
return 0;
}
int numFSs = ((IndexIteratorCachePair) indexVector.get(0)).index.size();
final Vector typeVector = this.typeSystem.getDirectlySubsumedTypes(type);
final int max = typeVector.size();
for (int i = 0; i < max; i++) {
numFSs += getIndexSize((Type) typeVector.get(i));
}
return numFSs;
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#createComparator()
*/
public FSIndexComparator createComparator() {
return new FSIndexComparatorImpl(this.cas);
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#isCommitted()
*/
public boolean isCommitted() {
return this.locked;
}
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#createIndexComparator()
*/
// public FSIndexComparator createIndexComparator() {
// return new FSIndexComparatorImpl(this.cas);
// }
/**
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#createIndex(org.apache.uima.cas.admin.FSIndexComparator,
* java.lang.String)
*/
public boolean createIndex(FSIndexComparator comp, String label) throws CASAdminException {
return createIndex(comp, label, FSIndex.SORTED_INDEX);
}
// ///////////////////////////////////////////////////////////////////////////
// Serialization support
/**
* Return an array containing all FSs in any index. This is intended to be used for serialization.
* Note that duplicate entries in indexes will appear in the array as many times as they occur in
* an index. The order in which FSs occur in the array does not reflect the order in which they
* were added to the repository. This means that set indexes deserialized from this list may
* contain different but equal elements than the original index.
*/
public int[] getIndexedFSs() {
IntVector v = new IntVector();
IndexIteratorCachePair iicp;
IntPointerIterator it;
ArrayList iv, cv;
// We may need to profile this. If this is a bottleneck, use a different
// implementation.
SortedIntSet set;
int jMax, indStrat;
// Iterate over all types.
for (int i = 0; i < this.indexArray.length; i++) {
iv = this.indexArray[i];
if (iv == null) {
// The 0 position is the only one that should be null.
continue;
}
// Iterate over the indexes for the type.
jMax = iv.size();
// Create a vector of IICPs. If there is at least one sorted or bag
// index, pick one arbitrarily and add its FSs (since it contains all
// FSs that all other indexes for the same type contain). If there are
// only set indexes, create a set of the FSs in those indexes, since they
// may all contain different elements (FSs that are duplicates for one
// index may not be duplicates for a different one).
cv = new ArrayList();
for (int j = 0; j < jMax; j++) {
iicp = (IndexIteratorCachePair) iv.get(j);
indStrat = iicp.index.getIndexingStrategy();
if (indStrat == FSIndex.SET_INDEX) {
cv.add(iicp);
} else {
if (cv.size() > 0) {
cv = new ArrayList();
}
cv.add(iicp);
break;
}
}
if (cv.size() > 0) {
set = new SortedIntSet();
for (int k = 0; k < cv.size(); k++) {
it = ((IndexIteratorCachePair) cv.get(k)).index.refIterator();
while (it.isValid()) {
set.add(it.get());
it.inc();
}
}
for (int k = 0; k < set.size(); k++) {
v.add(set.get(k));
}
}
}
return v.toArray();
}
/**
* @see org.apache.uima.cas.FSIndexRepository#addFS(org.apache.uima.cas.FeatureStructure)
*/
public void addFS(FeatureStructure fs) {
addFS(((FeatureStructureImpl) fs).getAddress());
}
private void incrementIllegalIndexUpdateDetector(int typeCode) {
this.detectIllegalIndexUpdates[typeCode]++;
}
/**
* @see org.apache.uima.cas.FSIndexRepository#removeFS(org.apache.uima.cas.FeatureStructure)
*/
public void removeFS(FeatureStructure fs) {
ll_removeFS(this.cas.ll_getFSRef(fs));
// final int typeCode =
// this.cas.ll_getFSRefType(this.cas.ll_getFSRef(fs));
// // final TypeImpl type = (TypeImpl) fs.getType();
// ArrayList idxList = this.indexArray[typeCode];
// final int max = idxList.size();
// incrementIllegalIndexUpdateDetector(typeCode);
// for (int i = 0; i < max; i++) {
// ((IndexIteratorCachePair) idxList.get(i)).index.deleteFS(fs);
// }
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.cas.admin.FSIndexRepositoryMgr#createTypeSortOrder()
*/
public LinearTypeOrderBuilder createTypeSortOrder() {
LinearTypeOrderBuilder orderBuilder = new LinearTypeOrderBuilderImpl(this.typeSystem);
if (this.defaultOrderBuilder == null) {
this.defaultOrderBuilder = orderBuilder;
}
return orderBuilder;
}
// private static final void bubbleSort(Object[] array, int end)
// {
// int comp;
// Object tmp;
// for (int i = (end - 1); i >= 0; i--)
// {
// for (int j = 1; j <= i; j++)
// {
// comp = ((Comparable) array[j - 1]).compareTo(array[j]);
// if (comp > 0)
// {
// tmp = array[j - 1];
// array[j - 1] = array[j];
// array[j] = tmp;
// }
// }
// }
// }
public LowLevelIndex ll_getIndex(String indexName) {
return (LowLevelIndex) getIndex(indexName);
}
public LowLevelIndex ll_getIndex(String indexName, int typeCode) {
if (!this.typeSystem.isType(typeCode) || !this.cas.isFSRefType(typeCode)) {
LowLevelException e = new LowLevelException(LowLevelException.INVALID_INDEX_TYPE);
e.addArgument(Integer.toString(typeCode));
throw e;
}
return (LowLevelIndex) getIndex(indexName, this.typeSystem.ll_getTypeForCode(typeCode));
}
public final void ll_addFS(int fsRef, boolean doChecks) {
if (doChecks) {
this.cas.checkFsRef(fsRef);
this.cas.isFSRefType(this.cas.ll_getFSRefType(fsRef));
}
ll_addFS(fsRef);
}
public void ll_addFS(int fsRef) {
// Determine type of FS.
final int typeCode = this.cas.getHeapValue(fsRef);
// indicate this type's indexes are being modified
// in case an iterator is simultaneously active over this type
incrementIllegalIndexUpdateDetector(typeCode);
// Get the indexes for the type.
final ArrayList indexes = this.indexArray[typeCode];
// Add fsRef to all indexes.
final int size = indexes.size();
for (int i = 0; i < size; i++) {
((IndexIteratorCachePair) indexes.get(i)).index.insert(fsRef);
}
if (size == 0) {
// lazily create a default bag index for this type
Type type = this.typeSystem.getType(typeCode);
String defIndexName = getAutoIndexNameForType(type);
FSIndexComparator comparator = createComparator();
comparator.setType(type);
createIndexNoQuestionsAsked(comparator, defIndexName, FSIndex.DEFAULT_BAG_INDEX);
assert this.indexArray[typeCode].size() == 1;
// add the FS to the bag index
((IndexIteratorCachePair) this.indexArray[typeCode].get(0)).index.insert(fsRef);
}
}
private static final String getAutoIndexNameForType(Type type) {
return "_" + type.getName() + "_GeneratedIndex";
}
public void ll_removeFS(int fsRef) {
final int typeCode = this.cas.ll_getFSRefType(fsRef);
incrementIllegalIndexUpdateDetector(typeCode);
ArrayList idxList = this.indexArray[typeCode];
final int max = idxList.size();
for (int i = 0; i < max; i++) {
((IndexIteratorCachePair) idxList.get(i)).index.remove(fsRef);
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.cas.FSIndexRepository#getAllIndexedFS(org.apache.uima.cas.Type)
*/
public FSIterator getAllIndexedFS(Type type) {
List iteratorList = new ArrayList();
getAllIndexedFS(type, iteratorList);
return new FSIteratorAggregate(iteratorList);
}
private final void getAllIndexedFS(Type type, List iteratorList) {
// Start by looking for an auto-index. If one exists, no other index exists.
FSIndex autoIndex = getIndex(getAutoIndexNameForType(type));
if (autoIndex != null) {
iteratorList.add(autoIndex.iterator());
// We found one of the special auto-indexes which don't inherit down the tree. So, we
// manually need to traverse the inheritance tree to look for more indexes. Note that
// this is not necessary when we have a regular index
List subtypes = this.typeSystem.getDirectSubtypes(type);
for (int i = 0; i < subtypes.size(); i++) {
getAllIndexedFS((Type) subtypes.get(i), iteratorList);
}
return;
}
// Attempt to find a non-set index first.
// If none found, then use the an arbitrary set index if any.
FSIndex setIndex = null;
Iterator iter = getLabels();
while (iter.hasNext()) {
String label = (String) iter.next();
FSIndex index = getIndex(label);
// Ignore auto-indexes at this stage, they're handled above.
if (index.getIndexingStrategy() == FSIndex.DEFAULT_BAG_INDEX) {
continue;
}
if (this.typeSystem.subsumes(index.getType(), type)) {
if (index.getIndexingStrategy() != FSIndex.SET_INDEX) {
iteratorList.add(getIndex(label, type).iterator());
// Done, found non-set index.
return;
}
setIndex = getIndex(label, type);
}
}
// No sorted or bag index found for this type. If there was a set index,
// return an iterator for it.
if (setIndex != null) {
iteratorList.add(setIndex.iterator());
return;
}
// No index for this type was found at all. Since the auto-indexes are created on demand for
// each type, there may be gaps in the inheritance chain. So keep descending the inheritance
// tree looking for relevant indexes.
List subtypes = this.typeSystem.getDirectSubtypes(type);
for (int i = 0; i < subtypes.size(); i++) {
getAllIndexedFS((Type) subtypes.get(i), iteratorList);
}
}
}