How to use

dequeue

method

in

it.unimi.dsi.fastutil.ints.IntHeapSemiIndirectPriorityQueue

private int hasNextInternal() {
  if ( positionQueue.isEmpty() ) return -1;
  
  int first;
  
  while ( curr[ first = positionQueue.first() ] == last ) {
    if ( ++currPos[ first ] == count[ first ] ) {
      positionQueue.dequeue();
      if ( positionQueue.isEmpty() ) return -1;
    }
    else {
      curr[ first ] = position[ first ][ currPos[ first ] ];
      positionQueue.changed();
    }
  }
  return first;
}

public int skipTo( final int p ) throws IOException {
  if ( curr >= p ) return curr;
  if ( p >= indexReader.index.numberOfDocuments ) return curr = END_OF_LIST;
  int i, d;
  
  //System.err.println( "Advancing to " + n  + " doc: " + Arrays.toString( doc ) + " first: " + queue.first() );
  while( ! queue.isEmpty() && globalDocumentPointer[ i = queue.first() ] < p ) {
    d = documentIterator[ i ].skipTo( strategy.localPointer( p ) );
    if ( d == END_OF_LIST ) queue.dequeue();
    else {
      globalDocumentPointer[ i ] = strategy.globalPointer( usedIndex[ i ], d );
      if ( globalDocumentPointer[ i ] < p ) queue.dequeue(); // This covers the case of getting to the end of list without finding p 
      else queue.changed();
    }
  }
  
  if ( queue.isEmpty() ) return curr = END_OF_LIST;
  return curr = globalDocumentPointer[ currentIterator = queue.first() ];
}

public int nextDocument() throws IOException {
  if ( curr == END_OF_LIST ) return END_OF_LIST;
  if ( curr != -1 ) {
    final int result;
    if ( ( result = documentIterator[ currentIterator ].nextDocument() ) != END_OF_LIST ) {
      globalDocumentPointer[ currentIterator ] = strategy.globalPointer( usedIndex[ currentIterator ], result );
      queue.changed();
    }
    else queue.dequeue();
  }
  return curr = queue.isEmpty() ? END_OF_LIST : globalDocumentPointer[ currentIterator = queue.first() ];
}

public int skipTo( final int p ) throws IOException {
  ahead = false;
  if ( curr >= p ) return curr;
  if ( p >= indexReader.index.numberOfDocuments ) return curr = END_OF_LIST;
  int i, d;
  
  //System.err.println( "Advancing to " + n  + " doc: " + Arrays.toString( doc ) + " first: " + queue.first() );
  while( ! queue.isEmpty() && globalDocumentPointer[ i = queue.first() ] < p ) {
    d = documentIterator[ i ].skipTo( strategy.localPointer( p ) );
    if ( d == Integer.MAX_VALUE ) queue.dequeue();
    else {
      globalDocumentPointer[ i ] = strategy.globalPointer( usedIndex[ i ], d );
      if ( globalDocumentPointer[ i ] < p ) queue.dequeue(); // This covers the case of getting to the end of list without finding p 
      else queue.changed();
    }
  }
  
  if ( queue.isEmpty() ) return curr = END_OF_LIST;
  return curr = globalDocumentPointer[ currentIterator = queue.first() ];
}

public Interval nextInterval() {
  if ( next != null ) {
    final Interval result = next;
    next = null;
    return result;
  }
  
  if ( emitted < extracted ) return Interval.valueOf( cache[ emitted++ ] );
  if ( positionQueue.isEmpty() ) return null;
  final int first = positionQueue.first();
  if ( extracted == cache.length ) cache = IntArrays.grow( cache, extracted + 1 );
  cache[ extracted++ ] = curr[ first ];
  if ( ++currPos[ first ] < count[ first ] ) {
    curr[ first ] = position[ first ][ currPos[ first ] ];
    positionQueue.changed();
    if ( curr[ positionQueue.first() ] == cache[ extracted - 1 ] ) throw new IllegalArgumentException( "Duplicate positions in " + this );
  }
  else positionQueue.dequeue();
    
  return Interval.valueOf( cache[ emitted++ ] );
}

protected int nextDocumentInternal() throws IOException {
  final int result;
  if ( ( result = documentIterator[ currentIterator ].nextDocument() ) != -1 ) {
    globalDocumentPointer[ currentIterator ] = strategy.globalPointer( usedIndex[ currentIterator ], result );
    queue.changed();
  }
  else queue.dequeue();
  curr = queue.isEmpty() ? END_OF_LIST : globalDocumentPointer[ currentIterator = queue.first() ];
  return toNextDocument( curr );
}

public Interval nextInterval() {
  if ( next != null ) {
    final Interval result = next;
    next = null;
    return result;
  }
  
  if ( emitted < extracted ) return Interval.valueOf( cache[ emitted++ ] );
  if ( positionQueue.isEmpty() ) return null;
  final int first = positionQueue.first();
  if ( extracted == cache.length ) cache = IntArrays.grow( cache, extracted + 1 );
  cache[ extracted++ ] = curr[ first ];
  if ( ++currPos[ first ] < count[ first ] ) {
    curr[ first ] = position[ first ][ currPos[ first ] ];
    positionQueue.changed();
    if ( curr[ positionQueue.first() ] == cache[ extracted - 1 ] ) throw new IllegalArgumentException( "Duplicate positions in " + this );
  }
  else positionQueue.dequeue();
    
  return Interval.valueOf( cache[ emitted++ ] );
}

public int skipTo( final int n ) throws IOException {
  ahead = false;
  if ( curr >= n ) return curr;
  currentIterators.clear(); 
  frontSize = -1; // Invalidate front
  int first, res;
  while( refArray[ first = queue.first() ] < n ) {
    // Cannot advance the minimum
    if ( ( res = documentIterator[ first ].skipTo( n ) ) == END_OF_LIST ) {
      // Remove it
      queue.dequeue();
      // If nothing else remains, we are done
      if ( queue.isEmpty() ) return curr = END_OF_LIST;
    }
    else {
      // Advance the top element, and signal this fact to the queue
      refArray[ first ] = res;
      queue.changed();
    }
  }
  
  return curr = refArray[ first ];
}

successor[d] = (prevTarget[i] += batchIbs[i].readDelta() + 1);
if (--inputStreamLength[i] == 0) {
  queue.dequeue();
  batchIbs[i].close();
  batchIbs[i] = null;

protected int nextDocumentInternal() throws IOException {
  currentIterators.clear(); 
  frontSize = -1; // Invalidate front
  
  // The least element
  int first, c = refArray[ queue.first() ];

  // Advance all elements equal to the least one
  while( refArray[ first = queue.first() ] == c ) {
    if ( ( refArray[ first ] = documentIterator[ first ].nextDocument() ) != - 1 ) queue.changed();
    else {
      // Remove it
      queue.dequeue();
      // If nothing else remains, we are done
      if ( queue.isEmpty() ) {
        curr = END_OF_LIST;
        return -1;
      }
    }
  }
  return curr = refArray[ first ];
}

public Interval nextInterval() {
  if ( next != null ) {
    final Interval result = next;
    next = null; 
    return result;
  }
  
  if ( positionQueue.isEmpty() ) return null;
  
  int first = positionQueue.first();
  final int previous = curr[ first ];
  
  do
    if ( ++currPos[ first ] == count[ first ] ) {
      positionQueue.dequeue();
      if ( positionQueue.isEmpty() ) return null;
    }
    else {
      curr[ first ] = position[ first ][ currPos[ first ] ];
      positionQueue.changed();
    }
  while ( curr[ first = positionQueue.first() ] == previous );
  return Interval.valueOf( curr[ first ] );
}

if ( --frequency[ currIndex ] == 0 ) documentQueue.dequeue();
else {
  doc[ currIndex ] = ir.nextDocument();

if ( --frequency[ currIndex ] == 0 ) documentQueue.dequeue();
else {
  doc[ currIndex ] = ir.nextDocument();