Determine if the response body is repeatable (readable + seekable)

@return bool
@deprecated Use getResponseBody()->isSeekable()
@codeCoverageIgnore
171944
public function isResponseBodyRepeatable()
    {
        Version::warn(__METHOD__ . ' is deprecated. Use $request->getResponseBody()->isRepeatable()');
        return !$this->responseBody ? true : $this->responseBody->isRepeatable();
    }
139924
public function isReadable() {
		$m = substr($this->mode, 0, 1);
		$p = strlen($this->mode) > 1 ? substr($this->mode, 1, 2) : "";
		return ($m == "r" || $p == "+");
	}
358404
public function isReadOnly()
    {
        $readOnly = false;
        $fields   = $this->getPart(Zend_Db_Table_Select::COLUMNS);
        $cols     = $this->_info[Zend_Db_Table_Abstract::COLS];

        if (!count($fields)) {
            return $readOnly;
        }

        foreach ($fields as $columnEntry) {
            $column = $columnEntry[1];
            $alias = $columnEntry[2];

            if ($alias !== null) {
                $column = $alias;
            }

            switch (true) {
                case ($column == self::SQL_WILDCARD):
                    break;

                case ($column instanceof Zend_Db_Expr):
                case (!in_array($column, $cols)):
                    $readOnly = true;
                    break 2;
            }
        }

        return $readOnly;
    }
101538
public function isEnable()
    {
        if (!$this->mPDFExists() || !$this->collection()->getSize()) {
            return false;
        }

        return $this->hasConfig(self::ENABLE);
    }
1047421
public function isWritable() {

		if(false !== $this -> file -> getExists()) {

			$this -> refresh();
			
			return $this -> file -> getWritable();
		}

		return false;
	}
714727
public function isSeekable() : bool
	{
		if (! \is_resource($this->resource))
		{
			return false;
		}

		$metadata = \stream_get_meta_data($this->resource);

		return $metadata['seekable'];
	}
1111709
public function isAvailable()
    {
        $available = true;
        try {
            $this->redis->ping();
        } catch (RedisException $e) {
            $available = false;
        }

        return $available;
    }
84325
public function valid()
    {

        if ($this->container['response'] === null) {
            return false;
        }
        $allowedValues = $this->getResponseAllowableValues();
        if (!in_array($this->container['response'], $allowedValues)) {
            return false;
        }
        return true;
    }
958076
protected function isCompressable(ServerRequestInterface $request, ResponseInterface $response): bool
    {
        if ($request->getMethod() === Http::HEAD) {
            return false;
        }

        if (Http::isResponseWithoutBody($response->getStatusCode())) {
            return false;
        }

        if (!$response->hasHeader('Content-Type')) {
            return false;
        }

        $encoding = \strtolower(\preg_replace("';.*$'", '', $response->getHeaderLine('Content-Encoding')));

        switch ($encoding) {
            case '':
            case 'identity':
                // These can be compressed.
                break;
            default:
                return false;
        }

        try {
            $media = new MediaType(\preg_replace("';.*$'", '', $response->getHeaderLine('Content-Type')));
        } catch (InvalidMediaTypeException $e) {
            return false;
        }

        if (isset($this->types[(string) $media])) {
            return true;
        }

        foreach ($media->getSubTypes() as $sub) {
            if (isset($this->subTypes[$sub])) {
                return true;
            }
        }

        return false;
    }
701826
protected function isRepeatRelational()
    {
        $is_repeat = false;
        
        if (array_count_values($this->getParentArray())[$this->prefix] > 1) {
            $is_repeat = true;
        }
        
        return $is_repeat;
    }
943747
public function canResponseSatisfyFailedRequest(RequestInterface $request, Response $response)
    {
        $reqc = $request->getHeader('Cache-Control');
        $resc = $response->getHeader('Cache-Control');
        $requestStaleIfError = $reqc ? $reqc->getDirective('stale-if-error') : null;
        $responseStaleIfError = $resc ? $resc->getDirective('stale-if-error') : null;

        if (!$requestStaleIfError && !$responseStaleIfError) {
            return false;
        }

        if (is_numeric($requestStaleIfError) && $response->getAge() - $response->getMaxAge() > $requestStaleIfError) {
            return false;
        }

        if (is_numeric($responseStaleIfError) && $response->getAge() - $response->getMaxAge() > $responseStaleIfError) {
            return false;
        }

        return true;
    }
898802
protected function isRestorable()
    {
        return
            $this->restorable
            &&
            $this->isTrashed()
            &&
            $this->getModelConfiguration()->isRestorable(
                $this->getModel()
            );
    }
991433
private function isTable(){
        try {
            if($table = $this->GetTable()){
                $sql = 'SHOW COLUMNS FROM '.$table;
                return $res = $this->query($sql)->all();
            }
        }catch(\Exception $e){
            echo $e->getMessage();
        }
        return false;
    }
756894
public function has_actual_responses() {
        $actualresponses = $this->get_responses();
        if (count($actualresponses) > 1) {
            return true;
        } else if (count($actualresponses) === 1) {
            $singleactualresponse = reset($actualresponses);
            return (string)$singleactualresponse !== (string)$this->modelresponse;
        }
        return false;
    }
405869
public function canResponseSatisfyRequest(RequestInterface $request, Response $response)
    {
        $responseAge = $response->calculateAge();
        $reqc = $request->getHeader('Cache-Control');
        $resc = $response->getHeader('Cache-Control');

        // Check the request's max-age header against the age of the response
        if ($reqc && $reqc->hasDirective('max-age') &&
            $responseAge > $reqc->getDirective('max-age')) {
            return false;
        }

        // Check the response's max-age header
        if ($response->isFresh() === false) {
            $maxStale = $reqc ? $reqc->getDirective('max-stale') : null;
            if (null !== $maxStale) {
                if ($maxStale !== true && $response->getFreshness() < (-1 * $maxStale)) {
                    return false;
                }
            } elseif ($resc && $resc->hasDirective('max-age')
                && $responseAge > $resc->getDirective('max-age')
            ) {
                return false;
            }
        }

        if ($this->revalidation->shouldRevalidate($request, $response)) {
            try {
                return $this->revalidation->revalidate($request, $response);
            } catch (CurlException $e) {
                $request->getParams()->set('cache.hit', 'error');
                return $this->canResponseSatisfyFailedRequest($request, $response);
            }
        }

        return true;
    }
75072
public function isReadable() {

		if(false !== $this -> file -> getExists()) {

			$this -> refresh();
			
			return $this -> file -> getReadable();
		}

		return false;
	}
1371472
public function isRewindable()
    {
        if (null !== $this->rewindable) {
            return $this->rewindable;
        }

        // workaround for an HHVM bug, should be removed when https://github.com/facebook/hhvm/issues/7281 is fixed
        if ('' === $this->getPath()) {
            return $this->rewindable = false;
        }

        if (false !== $stream = @opendir($this->getPath())) {
            $infos = stream_get_meta_data($stream);
            closedir($stream);

            if ($infos['seekable']) {
                return $this->rewindable = true;
            }
        }

        return $this->rewindable = false;
    }