Check if the current position of the pointer is valid

@return bool True if the pointer position is valid
7
public function valid() : bool
    {
        if ($this->pointer >= 0 && $this->pointer < count($this->members)) {
            return true;
        }
        return false;
    }
820070
public function valid()
    {

        $allowedValues = $this->getStateAllowableValues();
        if (!in_array($this->container['state'], $allowedValues)) {
            return false;
        }
        return true;
    }
136697
public function is_valid() {
        $ret = false ;

        if (parent::is_valid() === true) {
            if (is_null($this->id) === false && is_null($this->logicalConnectorWithNext) === false &&
                is_null($this->negation) === false && is_null($this->groupedWith) === false
            ) {
                $ret = true;
            }
        }

        return $ret;
    }
999058
public function valid()
    {
        // initialize/refresh cursor
        if ($this->cursor != 0 && !isset($this->elements[$this->index])) {
            $this->scan();
        }

        return isset($this->elements[$this->index]);
    }
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;
        }
    }
297150
public function valid()
    {
        if ($this->flags & SplFileObject::READ_AHEAD) {
            return $this->current() !== false;
        }

        return !feof($this->stream);
    }
1266758
public function valid()
    {
        $key = isset($this->items[$this->pos]) ? $this->items[$this->pos] : null;
        return ($key !== null && $key !== false);
    }
1201179
public function isValid()
	{
		return isset($this->path)
			|| isset($this->params)
			|| isset($this->anchor)
			|| isset($this->secure)
			|| isset($this->host)
			|| isset($this->port)
			|| isset($this->user)
			|| isset($this->pass);
	}
1130374
public function isValid()
    {
        $vertices = $this->getGraph()->getVertices()->getMap();
        // check source graph contains all vertices
        foreach ($this->getVertices()->getMap() as $vid => $vertex) {
            // make sure vertex ID exists and has not been replaced
            if (!isset($vertices[$vid]) || $vertices[$vid] !== $vertex) {
                return false;
            }
        }
        $edges = $this->getGraph()->getEdges()->getVector();
        // check source graph contains all edges
        foreach ($this->edges as $edge) {
            if (!in_array($edge, $edges, true)) {
                return false;
            }
        }

        return true;
    }
46868
public function valid()
    {

        if ($this->container['name'] === null) {
            return false;
        }
        if (strlen($this->container['name']) > 40) {
            return false;
        }
        if (strlen($this->container['name']) < 1) {
            return false;
        }
        $allowedValues = $this->getColorAllowableValues();
        if (!in_array($this->container['color'], $allowedValues)) {
            return false;
        }
        return true;
    }
735796
public function valid()
  {

    $allowedValues = $this->getExclusionTypeAllowableValues();
    if (!in_array($this->container['exclusion_type'], $allowedValues)) {
      return false;
    }
    return true;
  }
915388
public function isValid(): bool
    {
        $segments = explode('.', $this->value, self::NUM_SEGMENTS);

        if (count($segments) !== self::NUM_SEGMENTS) {
            return false;
        }

        for ($i = 0; $i < self::NUM_SEGMENTS; $i++) {
            $value = (int) $segments[$i];

            if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
                return false;
            }
        }

        return true;
    }
1283493
public function valid()
    {
        if (is_null($this->current)) {
            return ! empty($this->branch);
        }
        if ($this->current instanceof RecursiveLeafInterface) {
            return $this->current->valid();
        }

        return false;
    }
29178
public function valid(): bool
    {
        if ($this->cacheFilesIterator === null) {
            $this->rewind();
        }
        return $this->cacheFilesIterator->valid();
    }
49155
public function valid()
    {
        if ($this->_countParts === null) {
            $this->countParts();
        }
        return $this->_iterationPos && $this->_iterationPos <= $this->_countParts;
    }
1098226
public function isValid()
    {
        $valid = $this->prefix != '';
        $valid = $valid && $this->startMultiLine != '';
        $valid = $valid && $this->endMultiLine != '';
        $valid = $valid && $this->simpleDirective != '';

        return $valid;
    }
83864
public function isValid() {

		if(!isset($this->valid)) {
            $this->valid = $this->applyValidators(
                $this->applyModifiers($this->getValue())
            );
		}

		return $this->valid;

	}