Moves to the next log record in reverse order. If the current log record
is the earliest in its block, then the method moves to the next oldest
block, and returns the log record from there.

@return the next earliest log record
495041
@Override
	public BasicLogRecord next() {
		if (!isForward) {
			currentRec = currentRec - pointerSize;
			isForward = true;
		}
		if (currentRec == 0)
			moveToNextBlock();
		currentRec = (Integer) pg.getVal(currentRec, INTEGER).asJavaVal();
		return new BasicLogRecord(pg, new LogSeqNum(blk.number(), currentRec + pointerSize * 2));
	}
658859
@Override
	public final int next(int handle) throws DataStoreException
    {
        if (SAFE_MODE) checkHandle(handle);
        
        int current = nextBlock[handle];
        while (current != -1 && (flags[current] & FLAG_START_BLOCK) == 0)
            current = nextBlock[current];

        return current;
    }
640058
public long getNearestPosition(long recordNumber) {
        if (recordNumber < startingRecordNumber || recordNumber > lastRecordNumber)
            throw new IndexOutOfBoundsException();
        return index.get((int) ((recordNumber - startingRecordNumber) / step));
    }
1301849
public synchronized Entry getPreviousEntry()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "getPreviousEntry");
    
    checkEntryParent();
    
    Entry previousEntry = null;
    
    synchronized(parentList)
    {            
      if(atBottom)
      {
        //if at the bottom of the list, return the last entry in the list
        previousEntry = parentList.last;
      }
      else if(!atTop)                        
      {
        //otherwise it's just the previous entry in the list
        previousEntry = current.getPrevious();                        
      }
      //if the cursor is at the top of the list then we should
      //just drop through and the previous entry is null
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "getPreviousEntry", previousEntry);

    return previousEntry;
  }
198783
public Object next()
    {
        String result = null;

        if ( _literal != null )
        {
            result = _literal;
            _literal = null;
        }
        else if ( _token != null )
        {
            result = _token;
            _token = null;
        }
        return result;
    }
1134697
public Integer next() {
		for(int i = currentIndex; i < t.size(); i++){
			if(i+timelag>=t.size()){
				return null;
			}
			if((t.get(i) != null) && (t.get(i+timelag) != null)){
				if(overlap){
					currentIndex = i+1;
				}
				else{
					currentIndex = i+timelag;
				}
				return i;
			}
		}
		
		return null;
	}
366881
public File next() throws IOException {
        if (stack.isEmpty()) {
            current = null;
            return null;
        } else {
            current = stack.removeLast();
            if (current.isDirectory()) {
                if (stack.size() < rootCount) {
                    rootCount = stack.size();
                }
                addReverse(current.listFiles());
                return next();
            } else {
                return current;
            }
        }
    }
1297610
public A next() {
        A x = elems.head;
        if (!elems.isEmpty()) {
            elems = elems.tail;
            if (elems.isEmpty()) last = null;
            count--;
        }
        return x;
    }
1271491
public Object next()
    {
        _current1.reset();
        if (_last1.key() == null)
            findFirst(_dstack);
        else
        {
            findNext(_dstack);
            if (_current1.key() == null)
                _eof = true;
        }

        if (_current1.key() != null)
            _last1.setLocation(_current1);

        return _current1.key();
    }
717174
def next(self):
        
        if self._current < len(self._record_list):
            rec = self._record_list[self._current]
            key = rec['name']
            self._current += 1
            return key
        else:
            raise StopIteration
1139450
public static <C extends Comparable> Ordering<Range<C>> reverseOrderingByLowerEndpoint() {
        Ordering<Range<C>> orderingByLowerEndpoint = orderingByLowerEndpoint();
        return orderingByLowerEndpoint.reverse();
    }
1190391
public RepositoryLogRecord next() {
		RepositoryLogRecord result = null;
		if (curPos >= logRecordList.size()) {
			loadNext();
		}
		if (curPos < logRecordList.size()) {
			result = logRecordList.get(curPos++) ;
		}
		pointer = result==null ? null : result.getRepositoryPointer();
		return result;
	}
1175854
public Record getMainRecord()
    {
        Record record = null;
        if (this.size() > 0)
        {
            record = (Record)this.firstElement();
            if (record != null) if (record == this.getScreenRecord())
            {
                record = null;
                if (this.size() >= 2)
                    record = (Record)this.elementAt(1);
            }
        }
        return record;
    }
374385
@Override
    public IChemObject previous() {
        try {
            return readRecord(currentRecord - 1);
        } catch (Exception x) {
            logger.error(x);
            return null;
        }
    }
901472
public TarEntry getNextEntry() throws IOException {
		closeCurrentEntry();

		byte[] header = new byte[TarConstants.HEADER_BLOCK];
		byte[] theader = new byte[TarConstants.HEADER_BLOCK];
		int tr = 0;

		// Read full header
		while (tr < TarConstants.HEADER_BLOCK) {
			int res = read(theader, 0, TarConstants.HEADER_BLOCK - tr);

			if (res < 0) {
				break;
			}

			System.arraycopy(theader, 0, header, tr, res);
			tr += res;
		}

		// Check if record is null
		boolean eof = true;
		for (byte b : header) {
			if (b != 0) {
				eof = false;
				break;
			}
		}

		if (!eof) {
			currentEntry = new TarEntry(header);
		}

		return currentEntry;
	}
1294232
public boolean next() {
		while (true) {
			currentSlot++;
			if (!isOverflowing) { // not in an overflow block
				// if it reached the end of the block
				if (currentSlot >= currentPage.getNumRecords()) {
					if (getSiblingFlag(currentPage) != -1) {
						moveTo(getSiblingFlag(currentPage), -1);
						continue;
					}
					return false;
					// if the key of this slot match what we want
				} else if (searchRange.match(getKey(currentPage, currentSlot, keyType.length()))) {
					/*
					 * Move to records in overflow blocks first. An overflow block
					 * cannot be empty.
					 */
					if (currentSlot == 0 && getOverflowFlag(currentPage) != -1) {
						isOverflowing = true;
						overflowFrom = currentPage.currentBlk().number();
						moveTo(getOverflowFlag(currentPage), 0);
					}
					return true;
				} else if (searchRange.betweenMinAndMax(getKey(currentPage, currentSlot, keyType.length()))) {
					continue;
				} else
					return false;
			} else { // in an overflow block
				// All the records in an overflow block have the same key
				// so that we do not need to check the key in an overflow block.
				
				if (currentSlot >= currentPage.getNumRecords()) {
					moveTo(getOverflowFlag(currentPage), 0);
					/*
					 * Move back to the first record in the regular block finally.
					 */
					if (currentPage.currentBlk().number() == overflowFrom) {
						isOverflowing = false;
						overflowFrom = -1;
					}
				}
				
				return true;
			}
		}
	}
1331759
protected ORecordInternal<?> getRecord() {
		final ORecordInternal<?> record;
		if (reusedRecord != null) {
			// REUSE THE SAME RECORD AFTER HAVING RESETTED IT
			record = reusedRecord;
			record.reset();
		} else
			record = null;
		return record;
	}