Returns whether or not the iterator has more elements

@return bool
194443
public function valid()
    {
        if ($this->_buffer->offsetExists($this->_index)) {
            $current = $this->_buffer->offsetGet($this->_index);
            $this->_current = $current['value'];
            $this->_key = $current['key'];

            return true;
        }

        $valid = parent::valid();

        if ($valid) {
            $this->_current = parent::current();
            $this->_key = parent::key();
            $this->_buffer->push([
                'key' => $this->_key,
                'value' => $this->_current
            ]);
        }

        $this->_finished = !$valid;

        return $valid;
    }
91985
public function isSet() : bool
    {
        if (count($this->objects) < 1)
        {
            throw new Exception("ANDGroup contains too few objects");
        }

        $i = 0;

        foreach ($this->objects as $object)
        {
            if ($object->isSet())
            {
                $i++;
            }
        }

        return count($this->objects) === $i;
    }
49155
public function valid()
    {
        if ($this->_countParts === null) {
            $this->countParts();
        }
        return $this->_iterationPos && $this->_iterationPos <= $this->_countParts;
    }
670196
public function isEndElementOfEmptyElement()
    {
        return
            $this->reader->nodeType === XMLReader::END_ELEMENT
            && $this->lastDepth === $this->reader->depth
            && $this->lastNode instanceof DOMElement
            && !$this->reader->isEmptyElement;
    }
120395
@Override
	public boolean hasNext()
	{
		if (this.items != null)
			return i != this.itemsSize;
		else if (this.itemsIterator != null)
			return this.itemsIterator.hasNext();
		else
			return this.itemsEnumerator.hasMoreElements();
	}
1332407
private function _iterator()
    {
        if(!isset($this->_iterator))
            $this->_iterator = $this->_resultSet()->getIterator();

        return $this->_iterator;
    }
1070256
@Override
	public boolean hasMoreElements()
	{
		if (endOfQueueReached)
			return false;
		try
		{
			checkNotClosed();
			Message msg = fetchNext();
			return msg != null;
		}
		catch (JMSException e)
		{
			throw new IllegalStateException(e.toString());
		}
	}
1231610
public function valid() 
    {
        if (false === isset($this->iterators[$this->index])) {
            return false;
        }

        return $this->iterators[$this->index]->valid();
    }
1114185
public boolean hasNext() {

        if (items != null) {
            if (items.hasNext()) {
                return (true);
            } else {
                items = null;
            }
        }
        Object next = findNextValidChild();
        while (next != null) {
            initializeItems(next);
            if (items != null) {
                return true;
            } else {
                next = findNextValidChild();
            }
        }
        return false;

    }
813746
public function isEmpty(): bool
    {
        return $this->isNull()
            || (is_array($this->value) && count($this->value) === 0)
            || (is_string($this->value) && strlen($this->value) === 0);
    }
1061465
public function isMultidimensional() {
    foreach ($this->elements->getItems() as $element) {
      if ($element instanceof ArrayPairNode) {
        if ($element->getValue() instanceof ArrayNode) {
          return TRUE;
        }
      }
      elseif ($element instanceof ArrayNode) {
        return TRUE;
      }
    }
    return FALSE;
  }
1332123
public function isEmpty()
	{
		if ($this->partCount === 0) {
			return true;
		}
		if ($this->partCount === 1) {
			return $this->firstPart === '';
		}
		if ($this->partCount === 3 && $this->isStreamWrapped()) {
			return true;
		}
		return false;
	}
21002
public function hasSingleChildBlockElement()
    {
        $result = false;
        if ($this->hasChildNodes()) {
            foreach ($this->getChildren() as $child) {
                if (in_array($child->nodeName, $this->divToPElements)) {
                    $result = true;
                } else {
                    // If any of the hasSingleChildBlockElement calls return true, return true then.
                    /** @var $child DOMElement */
                    $result = ($result || $child->hasSingleChildBlockElement());
                }
            }
        }

        return $result;
    }
1230216
public function hasPatterns()
    {
        return (boolean) count($this->includesFileList) > 0 || count($this->excludesFileList) > 0
            || count($this->includeList) > 0 || count($this->excludeList) > 0;
    }
828879
public function isEmpty()
    {
        if ($this->isStarted()) {
            ++$this->usageIndex;
        }
        foreach ($this->data as &$data) {
            if (!empty($data)) {
                return false;
            }
        }

        return true;
    }
236454
@Override
    public boolean hasMoreElements() {
        // wind forward to the next non-empty enumeration
        while (index < enumerations.size() && !!!enumerations.get(index).hasMoreElements())
            index++;
        // return true iff there was a non-empty enumeration
        return index < enumerations.size();
    }
303372
public function isEmpty()
    {
        return $this->isNull()
            || (is_array($this->value) && count($this->value) === 0)
            || $this->length() === 0;
    }