Returns the next available indication for the specified KNX address.
<p>
See {@link #getNextIndication()} for more details. In contrast to that method, this
method does not throw.
484955
@Override
	public CEMILData request(final KNXAddress dst, final Configuration c)
	{
		if (!(dst instanceof GroupAddress))
			return null;
		final DatapointModel<?> m = c.getDatapointModel();
		if (m != null) {
			final Datapoint dp = m.get((GroupAddress) dst);
			if (dp == null || dp.isStateBased())
				return null;
		}
		synchronized (indicationKeys) {
			for (final Iterator<CacheObject> i = indicationKeys.iterator(); i.hasNext();) {
				final CacheObject co = i.next();
				if (co.getKey().equals(dst)) {
					i.remove();
					return ((LDataObjectQueue) co).getItem().getFrame();
				}
			}
		}
		return null;
	}
1335647
public Object getNextElement() {
        Object element = null;
        while (currentIndex+1 < endIndex && element == null) {
            currentIndex++;
            element = getElement();
        }
        return element;      
    }
1198548
public Optional<E> getNext() {
        return Optional.of(currentIndex).filter(getLess(linkedList.size() - 1))
                .map(i -> linkedList.get(++currentIndex));
    }
1106123
def next(self):
        
        result = javabridge.call(
            self.loader.jobject, "getNextInstance",
            "(Lweka/core/Instances;)Lweka/core/Instance;", self.structure.jobject)
        if result is None:
            raise StopIteration()
        else:
            return Instance(result)
890939
public synchronized Entry getNextEntry()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "getNextEntry");
    
    checkEntryParent();
    
    Entry nextEntry = null;
    
    synchronized(parentList)
    {
      if(atTop)
      {
        //if the cursor is at the top of the list, return the first entry in the list
        nextEntry = parentList.first;
      }
      else if(!atBottom)                        
      {
        //otherwise just return the next entry in the list
        nextEntry = current.getNext();                        
      }
      //if the cursor is at the bottom of the list then we should
      //just drop through and the next entry is null
    }
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "getNextEntry", nextEntry);
    
    return nextEntry;
  }
431352
public static HttpHandler getNext(HttpServerExchange httpServerExchange) {
		String chainId = httpServerExchange.getAttachment(CHAIN_ID);
		List<HttpHandler> handlersForId = handlerListById.get(chainId);
		Integer nextIndex = httpServerExchange.getAttachment(CHAIN_SEQ);
		// Check if we've reached the end of the chain.
		if (nextIndex < handlersForId.size()) {
			httpServerExchange.putAttachment(CHAIN_SEQ, nextIndex + 1);
			return handlersForId.get(nextIndex);
		}
		return null;
	}
16280
public Entry getNext()
  {
    checkEntryParent();
    
    Entry entry = null;
    
    if(!isLast())
    {
      entry = next;
    }

    return entry;
  }
511830
@Override
    protected E findNext(){
        while(true){
            E elem = delegate.next();
            if(elem==null || filter.select(elem))
                return elem;
        }
    }
483421
public ScreenLocation getNextLocation(short position, short setNewAnchor)
    {
        if (position == ScreenConstants.ADD_VIEW_BUFFER)
            position = ScreenConstants.ADD_SCREEN_VIEW_BUFFER;
        if (position == ScreenConstants.FIRST_LOCATION)
            position = ScreenConstants.FIRST_INPUT_LOCATION;
        return super.getNextLocation(position, setNewAnchor);
    }
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();
    }
837905
public IXPathToken lookUpTokens(final int paramNext) {

        int nextCount = paramNext;

        // save current position of the scanner, to restore it later
        final int lastPos = mPos;
        IXPathToken token = nextToken();

        while (--nextCount > 0) {
            token = nextToken();
            if (token.getType() == TokenType.SPACE) {
                nextCount++;
            }
        }

        // reset position
        mPos = lastPos;
        return token;
    }
1098106
@Override
    protected Path findNext(){
        E elem = delegate.next();
        return elem==null ? null : path.append(elem, index()+1);
    }
420199
public int getCurrentSelectedPosition() {
        return mDrawerBuilder.mAdapter.getSelections().size() == 0 ? -1 : mDrawerBuilder.mAdapter.getSelections().iterator().next();
    }
292651
@Nonnull
  @ReturnsMutableCopy
  public ICommonsList <DATATYPE> next ()
  {
    if (!hasNext ())
      throw new NoSuchElementException ();

    // Not for the very first item, as the first item is the original order
    final boolean bFirstItem = m_bUseLong ? m_nCombinationsLeft == m_nTotalCombinations
                                          : m_aCombinationsLeft.equals (m_aTotalCombinations);
    if (!bFirstItem)
    {
      final int nElementCount = m_aElements.length;
      final int nSlotCount = m_aIndexResult.length;

      int i = nSlotCount - 1;
      while (m_aIndexResult[i] == (nElementCount - nSlotCount + i))
      {
        i--;
      }
      m_aIndexResult[i]++;
      final int nIndexResultI = m_aIndexResult[i];
      for (int j = i + 1; j < nSlotCount; j++)
      {
        m_aIndexResult[j] = nIndexResultI + j - i;
      }
    }

    // One combination less
    if (m_bUseLong)
      m_nCombinationsLeft--;
    else
      m_aCombinationsLeft = m_aCombinationsLeft.subtract (BigInteger.ONE);

    // Build result list
    final ICommonsList <DATATYPE> aResult = new CommonsArrayList <> (m_aIndexResult.length);
    for (final int nIndex : m_aIndexResult)
      aResult.add (m_aElements[nIndex]);
    return aResult;
  }
900173
public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        // 'next' is guaranteed non-null by a hasNext() which returned true
        T returnObj = this.next;
        this.next = null;
        return returnObj;
    }
1344162
public boolean nextIndex(long index) {
    if (operationIndex + 1 == index) {
      currentOperation = OperationType.COMMAND;
      operationIndex++;
      return true;
    }
    return false;
  }
667534
protected int getNextNode()
  {
    if (m_foundLast)
      return DTM.NULL;

    int next = m_iterator.next();
    
    if (m_isFresh)
      m_isFresh = false;

    if (DTM.NULL == next)
      this.m_foundLast = true;

    return next;
  }