private FieldIndex findFieldIndex(final int index) { for (FieldIndex node = this.hashedFieldIndexes.getFirst(); node != null; node = node.getNext()) { if (node.getIndex() == index) { return node; } } return null; }
public ObjectSink[] getSinks() { if (this.sinks != null) { return sinks; } ObjectSink[] sinks = new ObjectSink[size()]; int at = 0; if (this.hashedFieldIndexes != null) { // Iterate the FieldIndexes to see if any are hashed for (FieldIndex fieldIndex = this.hashedFieldIndexes.getFirst(); fieldIndex != null; fieldIndex = fieldIndex.getNext()) { if (!fieldIndex.isHashed()) { continue; } // this field is hashed so set the existing hashKey and see if there is a sink for it final int index = fieldIndex.getIndex(); final Iterator it = this.hashedSinkMap.newIterator(); for (ObjectEntry entry = (ObjectEntry) it.next(); entry != null; entry = (ObjectEntry) it.next()) { HashKey hashKey = (HashKey) entry.getKey(); if (hashKey.getIndex() == index) { sinks[at++] = (ObjectSink) entry.getValue(); } } } } if (this.hashableSinks != null) { for (ObjectSinkNode sink = this.hashableSinks.getFirst(); sink != null; sink = sink.getNextObjectSinkNode()) { sinks[at++] = sink; } } if (this.otherSinks != null) { for (ObjectSinkNode sink = this.otherSinks.getFirst(); sink != null; sink = sink.getNextObjectSinkNode()) { sinks[at++] = sink; } } this.sinks = sinks; return sinks; }
void unHashSinks(final FieldIndex fieldIndex) { final int index = fieldIndex.getIndex(); // this is the list of sinks that need to be removed from the hashedSinkMap final List<HashKey> unhashedSinks = new ArrayList<HashKey>(); final Iterator iter = this.hashedSinkMap.newIterator(); ObjectHashMap.ObjectEntry entry = (ObjectHashMap.ObjectEntry) iter.next(); while (entry != null) { final AlphaNode alphaNode = (AlphaNode) entry.getValue(); final IndexableConstraint indexableConstraint = (IndexableConstraint) alphaNode.getConstraint(); // only alpha nodes that have an Operator.EQUAL are in sinks, so only check if it is // the right field index if (index == indexableConstraint.getFieldExtractor().getIndex()) { final FieldValue value = indexableConstraint.getField(); if (this.hashableSinks == null) { this.hashableSinks = new ObjectSinkNodeList(); } this.hashableSinks.add(alphaNode); unhashedSinks.add(new HashKey(index, value, fieldIndex.getFieldExtractor())); } entry = (ObjectHashMap.ObjectEntry) iter.next(); } for (HashKey hashKey : unhashedSinks) { this.hashedSinkMap.remove(hashKey); } if (this.hashedSinkMap.isEmpty()) { this.hashedSinkMap = null; } fieldIndex.setHashed(false); }
void hashSinks(final FieldIndex fieldIndex) { if (this.hashedSinkMap == null) { this.hashedSinkMap = new ObjectHashMap(); } final int index = fieldIndex.getIndex(); final InternalReadAccessor fieldReader = fieldIndex.getFieldExtractor(); ObjectSinkNode currentSink = this.hashableSinks.getFirst(); while (currentSink != null) { final AlphaNode alphaNode = (AlphaNode) currentSink; final AlphaNodeFieldConstraint fieldConstraint = alphaNode.getConstraint(); final IndexableConstraint indexableConstraint = (IndexableConstraint) fieldConstraint; // position to the next sink now because alphaNode may be removed if the index is equal. If we // were to do this // afterwards, currentSink.nextNode would be null currentSink = currentSink.getNextObjectSinkNode(); // only alpha nodes that have an Operator.EQUAL are in hashableSinks, so only check if it is // the right field index if (index == indexableConstraint.getFieldExtractor().getIndex()) { final FieldValue value = indexableConstraint.getField(); this.hashedSinkMap.put(new HashKey(index, value, fieldReader), alphaNode); // remove the alpha from the possible candidates of hashable sinks since it is now hashed hashableSinks.remove(alphaNode); } } if (this.hashableSinks.isEmpty()) { this.hashableSinks = null; } fieldIndex.setHashed(true); }
public HashKey(FieldIndex fieldIndex, Object value) { this.setValue(fieldIndex.getIndex(), value, fieldIndex.getFieldExtractor()); }