Returns `true` if this instance will request a single DataTable, `false` if requesting
more than one.

@return bool
974300
public function isRequestingSingleDataTable()
    {
        $requestArray = $this->request->getRequestArray() + $_GET + $_POST;
        $date   = Common::getRequestVar('date', null, 'string', $requestArray);
        $period = Common::getRequestVar('period', null, 'string', $requestArray);
        $idSite = Common::getRequestVar('idSite', null, 'string', $requestArray);

        if (Period::isMultiplePeriod($date, $period)
            || strpos($idSite, ',') !== false
            || $idSite == 'all'
        ) {
            return false;
        }

        return true;
    }
637052
public function is()
	{
		$this->routes = array(); 

		foreach(func_get_args() as $param)
		{
			if(!is_array($param))
			{
				$this->routes[] = $param;
				continue;
			}

			foreach ($param as $p) 
			{
				$this->routes[] = $p;
			}
		}

		$this->request = Request::path();

		$this->parseRoutes();

		foreach($this->routes as $route)
		{
			if(!Request::is($route))
			{
				continue;
			}

			foreach($this->bad_routes as $bad_route)
			{
				if(str_is($bad_route, $this->request))
				{
					return false;
				}
			}

			return true;		
		}

		return false;
	}
1087344
public function getAvailable()
    {
        if (!$this->getAvailableFrom() && !$this->getAvailableTill()) {
            return false;
        } elseif ($this->validateDate() && $this->validateAvailability()) {
            return true;
        }

        return false;
    }
604485
public function isLocalColumnsRequired()
    {
        foreach ($this->getLocalColumns() as $columnName) {
            if (!$this->getTable()->getColumn($columnName)->isNotNull()) {
                return false;
            }
        }

        return true;
    }
1231831
public function hasDataToRead()
    {
        if (!$this->isConnected()) {
            throw new ConnectionException('Not connected to any server.', $this->activeHost);
        }

        $isDataInBuffer = $this->connectionHasDataToRead($this->readTimeout[0], $this->readTimeout[1]);
        if (!$isDataInBuffer) {
            $this->observers->emptyBuffer();
        }
        return $isDataInBuffer;
    }
886793
public static function shouldLoadExpanded()
    {
        // if filter_column_recursive & filter_pattern_recursive are supplied, and flat isn't supplied
        // we have to load all the child subtables.
        return Common::getRequestVar('filter_column_recursive', false) !== false
            && Common::getRequestVar('filter_pattern_recursive', false) !== false
            && !self::shouldLoadFlatten();
    }
553342
public function hasTabs(): bool
    {
        if ( ! $this->layout || ! count($this->layout)) {
            return false;
        }

        foreach ($this->layout as $key => $value) {

            if ($value instanceof ModelFormTabDataInterface) {
                return true;
            }
        }

        return false;
    }
224825
public function allowRequest()
    {
        if ($this->config->get('circuitBreaker')->get('forceOpen')) {
            return false;
        }
        if ($this->config->get('circuitBreaker')->get('forceClosed')) {
            return true;
        }

        return !$this->isOpen() || $this->allowSingleTest();
    }
592710
protected function _isPaginationEnabled()
    {
        if (!isset($this->controller->limits) ||
            !isset($this->controller->limits[$this->action]) ||
            !isset($this->controller->limits[$this->action]['default']) ||
            !isset($this->controller->limits[$this->action]['limits'])
        ) {
            return false;
        }

        return true;
    }
614831
public function isObsolete()
    {
        if ($this->refreshNthRequests == 1 || $this->isRefreshNeededByProbability()) {
            return true;
        }
        if (isset($_SESSION['__HANDLER_REQUESTS_BEFORE_REFRESH'])) {
            if ($_SESSION['__HANDLER_REQUESTS_BEFORE_REFRESH'] <= 1) {
                return true; // @codeCoverageIgnore
            }
            $_SESSION['__HANDLER_REQUESTS_BEFORE_REFRESH']--;
        }
        if (isset($_SESSION['__HANDLER_SECONDS_BEFORE_REFRESH'])) {
            $timeDifference = time() - $_SESSION['__HANDLER_LAST_ACTIVITY_TIMESTAMP'];
            if ($timeDifference >= $_SESSION['__HANDLER_SECONDS_BEFORE_REFRESH']) {
                return true;
            }
        }
        return false;
    }
1343930
private function isFilterable(): bool
    {
        if (empty($this->user)) {
            return false;
        }

        if (! array_key_exists('id', $this->user)) {
            return false;
        }

        if ($this->isSuperuser()) {
            return false;
        }

        if ($this->isSkipTable()) {
            return false;
        }

        $controllerName = $this->getControllerClassName();

        // no relevant controller found for specified table
        if (! $controllerName) {
            return false;
        }

        // table's controller is cake's default controller, this is probably a many-to-many join table
        if ('Cake\Controller\Controller' === $controllerName) {
            return false;
        }

        return true;
    }
886697
public function canBeShowed(): bool
    {
        return ($this->mixed instanceof Collection || $this->mixed instanceof \Countable || is_int($this->mixed));
    }
1302878
function isMultiInsertSupported()
    {
        if ( $this->DBInstance instanceof eZDBInterface )
        {
            $versionInfo = $this->DBInstance->databaseServerVersion();

            // We require MySQL 3.22.5 to use multi-insert queries
            // http://dev.mysql.com/doc/mysql/en/INSERT.html
            return ( version_compare( $versionInfo['string'], '3.22.5' ) >= 0 );
        }
        return true;
    }
1369497
public function isAvailable()
    {
        $available = true;

        try {
            $this->connection->exec(
                \sprintf(
                    'SELECT %s FROM %s LIMIT 1',
                    self::TABLE_CACHE_ID,
                    $this->cacheTableName
                )
            );
        } catch (PDOException $e) {
            $available = false;
        }

        return $available;
    }
244405
public function hasRenderer()
    {
        if (!isset($this->_data['renderer'])) {
            return false;
        }

        if (is_string($this->_data['renderer'])) {
            // Renderer class name has been given
            $renderer = $this->_data['renderer'];
            $namespace = ResourceTable::collection()->rendererNamespace();
            if ($namespace) {
                $renderer = $namespace.'\\'.$renderer;
            }
            if (!class_exists($renderer)) {
                return false;
            }
            if (!method_exists($renderer, 'render') || !is_callable([$renderer, 'render'])) {
                return false;
            }
        }

        return true;
    }
879608
public function exists()
    {
        $quotedTable = \Database\DatabaseConnectionFactory::get()->quote($this->getTable());
        $record = \Database\DatabaseConnectionFactory::get()->query("show tables like {$quotedTable}");
        return !is_a($record, 'Database\DatabaseRecord\EmptyDatabaseRecord') && count($record->all()) > 0;
    }
27754
public function exclusivelySingle()
    {
        if (count($this) === 0) {
            return false;
        }

        foreach (array_keys($this->getDataPlaceHolder()) as $key) {
            $v = $this[$key];
            if (is_null($v) || $v instanceof Container) {
                return false;
            }
        }

        return true;
    }