Checks if current position is valid

@return boolean The return value will be casted to boolean and then evaluated.
Returns true on success or false on failure.
770801
public function valid() : bool
    {
        if (false === $this->result->fetch(\PDO::FETCH_ASSOC, \PDO::FETCH_ORI_ABS, $this->pointer)) {
            return false;
        }
        return true;
    }
394040
public function valid()
	{
		if( $this->next() )
			return TRUE;
		if( is_resource( $this->filePointer ) )
			fclose( $this->filePointer );
		return FALSE;
	}
1085664
public function valid()
    {
        if (key($this->_data) === null) {
            return false;
        }

        $current = current($this->_data);
        while (!$current->value()) {
            $current = $this->next();
            if (key($this->_data) === null) {
                return false;
            }
        }
        return true;
    }
1052472
public function valid() : bool
    {
        if ($this->pointer >= 0 && $this->pointer < $this->collection->length()) {
            return true;
        } else {
            return false;
        }
    }
1066364
public function isValid()
    {
        if ($this->valid === null) {
            $this->valid = true;

            if (sizeof($this->validators) > 0) {
                foreach ($this->validators as $validator) {
                    if (!$validator->isValid()) {
                        $this->errors[] = $validator->getErrorMessage();
                        $this->valid = false;
                    }
                }
            }
        }

        return $this->valid;
    }
824932
public function valid()
	{
		if ( is_null( $this->facts ) )
		{
			return false;
		}

		$result = $this->facts->valid();
		if ( ! $result )
		{
			$this->yieldedFact = null;
		}
		return $result;
	}
1080523
public function valid()
    {
        //echo 'v';
        $v = $this->currentIterator->valid();
        if (!$v) {
            do {
                $this->iterators->next();
                if ($this->iterators->valid()) {
                    $this->currentIterator = $this->iterators->current();
                    $this->currentIterator->rewind();
                }
            } while ($this->iterators->valid() && !$this->currentIterator->valid());

            if (!$this->currentIterator->valid()) {
                return false;
            } else {
                return true;
            }
        }

        return $v;
    }
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;
    }
417359
public function valid()
    {
        if ($this->_useBuffering) {
            $valid = $this->_index < $this->_count;
            if ($valid && $this->_results[$this->_index] !== null) {
                $this->_current = $this->_results[$this->_index];

                return true;
            }
            if (!$valid) {
                return $valid;
            }
        }

        $this->_current = $this->_fetchResult();
        $valid = $this->_current !== false;

        if ($valid && $this->_useBuffering) {
            $this->_results[$this->_index] = $this->_current;
        }
        if (!$valid && $this->_statement !== null) {
            $this->_statement->closeCursor();
        }

        return $valid;
    }
267513
final public function valid()
    {
        /**
         * Fetching is the most reliable way to check if we have a valid row.
         * Other methods were attempted, such as checking the current position against the result set count,
         * but sqlite lets us down here as the driver doesn't support count, so we have to fetch which screws everything up
         */
        $current = $this->getNextRow();

        # If we found a record, then seek back so that it can be fetched
        if (is_array($current)) {
            $this->seek($this->position - 1);
            return true;

        # If we didn't find a record then just return false
        } else {
            return false;
        }
    }
1055764
public function isValid()
    {
        $row = $this->getActulRow();

        if ($row[$this->column] >= $this->min  && $row[$this->column] <= $this->max) {
            return true;
        }
        return false;
    }
303365
final public function valid()
    {
        if ($this->position === -1) {
            $this->next();
        }

        return $this->offset + $this->position < $this->total;
    }
975841
public function valid()
    {
        if($this->folderList == null){
            $this->folderList = $this->listFolder();
        }
        return is_array($this->folderList) && isset($this->folderList[$this->key]);
    }
1321049
public function valid()
    {
        $keys = array_keys($this->tags);
        return isset($keys[$this->position]) && isset($this->tags[$keys[$this->position]]);
    }
992369
public function valid()
    {
		if ($this->dontUsePaging || !$this->itemCountPerPage)
		{		
			return $this->position >= 0 && $this->position < count($this->getElements());
		}
		if ($this->position < 0) return false;
		if ($this->itemCountPerPage && $this->position >= $this->itemCountPerPage) return false;
		if ($this->getPosition() >= count($this->getElements())) return false;
		return true;
    }
191308
public function isValid()
    {
        $payload = $this->getPayload();
        if (!isset($payload['exp'])) {
            return false;
        }

        $expireDateTime = DateTimeImmutable::createFromFormat('U', $payload['exp']);
        $now = new DateTime('now');
        return ($expireDateTime->getTimestamp() - $now->getTimestamp()) > 0;
    }
607029
public function isValid()
    {
        $result = true;
        $fields = $this->getFields();
        // Check each element for validators, validate them and return the result.
        foreach ($fields as $field) {
            if ($field->validate() == false) {
                $result = false;
            }
        }
        return $result;
    }