int bucketCount = 0;

        FastIterator it = LinkedList.fastIterator;

        for ( int i = 0, length = entries.length; i < length; i++ ) {

            if ( entries[i] != null ) {

                while ( rightTupleList != null ) {

                    if ( rightTupleList.first != null ) {

                        Entry entry = rightTupleList.first;

                        while ( entry != null ) {

                            entry = it.next( entry );

                            factCount++;

                        }

                    } else {

                        logger.info( "error : fieldIndexHashTable cannot have empty FieldIndexEntry objects" );

                    }

                    bucketCount++;

                }

            }

        }

                                                                         true, // this must always be true, otherwise we can't

                                                                               // find the child tuples to iterate for evaluating the query results

                                                                         query.isOpen() );

            if ( rightTuples == null ) {

                query.setResultInsertRightTupleList( rightTuples );

                QueryResultInsertAction evalAction = new QueryResultInsertAction( context,

                                                                                  this.factHandle,

                                                                                  leftTuple,

                                                                                  this.node );

                context.getQueue2().addFirst( evalAction );

            }

        }

            resultLeftTuple.setObject( null );

            DroolsQuery query = (DroolsQuery) this.factHandle.getObject();

            if ( rightTuples == null ) {

                query.setResultRetractRightTupleList( rightTuples );

                QueryResultRetractAction retractAction = new QueryResultRetractAction( context,

                                                                                       this.factHandle,

                                                                                       leftTuple,

                                                                                       this.node );

                context.getQueue2().addFirst( retractAction );

            }

            if ( rightTuple.getMemory() != null ) {

                throw new RuntimeException();

            }

        }

            }

            // Don't need to recreate child links, as they will already be there form the first "add"

            if ( rightTuples == null ) {

                query.setResultUpdateRightTupleList( rightTuples );

                QueryResultUpdateAction updateAction = new QueryResultUpdateAction( context,

                                                                                    this.factHandle,

                                                                                    leftTuple,

                                                                                    this.node );

                context.getQueue2().addFirst( updateAction );

            }

        }

                 int hashCode,

                 Object object) {

            lock();

            try {

                                                          object );

                this.tupleCount++;

            } finally {

                unlock();

            }

        }

                int c = keyCount - 1;

                RightTupleList[] tab = table;

                int index = hashCode & (tab.length - 1);

                while ( e != null ) {

                                    hashCode ) ) {

                        break;

                    }

                    e = (RightTupleList) e.next;

                }

                tupleCount--;

                    // list is empty, so remove it

                    for ( RightTupleList p = first; p != e; p = (RightTupleList) p.getNext() ) {

                                                       hashCode,

                                                       newFirst );

                    }

                    keyCount = c; // write-volatile

                }

            lock();

            try {

                RightTupleList[] tab = table;

                int index = hashCode & (tab.length - 1);

                while ( entry != null ) {

                                        hashCode ,

                                        factHandle ) ) {

                        return entry;

                    }

                }

                return entry;

            } finally {

                unlock();

            int c = keyCount;

            RightTupleList[] tab = table;

            int index = hashCode & (tab.length - 1);

            while ( e != null ) {

                                hashCode ) ) {

                    return e;

                }

                e = (RightTupleList) e.next;

            }

            if ( e == null ) {

                if ( c++ > threshold ) // ensure capacity

                    rehash();

                ++modCount;

                                        hashCode,

                                        first );

                tab[index] = e;

                keyCount = c; // write-volatile

            }

            int sizeMask = newTable.length - 1;

            for ( int i = 0; i < oldCapacity; i++ ) {

                // We need to guarantee that any existing reads of old Map can

                //  proceed. So we cannot yet null out each bin.

                if ( e != null ) {

                    int idx = e.hashCode() & sizeMask;

                    //  Single node on list

                    if ( next == null ) newTable[idx] = e;

                    else {

                        // Reuse trailing consecutive sequence at same slot

                        int lastIdx = idx;

                        for ( RightTupleList last = next; last != null; last = (RightTupleList) last.getNext() ) {

                            int k = last.hashCode() & sizeMask;

                            if ( k != lastIdx ) {

                                lastIdx = k;

                                lastRun = last;

                            }

                        }

                        newTable[lastIdx] = lastRun;

                        // Clone all remaining nodes

                        for ( RightTupleList p = e; p != lastRun; p = (RightTupleList) p.getNext() ) {

                            int k = p.hashCode() & sizeMask;

                        }

                    }

                }

            }

            table = newTable;

            // now process existing blocks, we only process existing and not new from above loop

            FastIterator rightIt = getRightIterator( rightTupleMemory );

            RightTuple rootBlocker = useComparisonIndex ? null : (RightTuple) rightIt.next(rightTuple);

         

           

            // we must do this after we have the next in memory

            // We add to the end to give an opportunity to re-match if in same bucket

            rightTupleMemory.removeAdd( rightTuple );