Returns true if this is the currently active page being used to handle this request.

@return bool
4078
public function isCurrent()
    {
        $currentPage = Director::get_current_page();
        if ($currentPage instanceof ContentController) {
            $currentPage = $currentPage->data();
        }
        if ($currentPage instanceof SiteTree) {
            return $currentPage === $this || $currentPage->ID === $this->ID;
        }
        return false;
    }
387592
public function isSection()
    {
        return $this->isCurrent() || (
            Director::get_current_page() instanceof SiteTree && in_array($this->ID, Director::get_current_page()->getAncestors()->column())
        );
    }
408117
public function currentRouteAction()
	{
		if ( ! $this->current()) return;

		$action = $this->current()->getAction();

		return isset($action['controller']) ? $action['controller'] : null;
	}
995126
protected function checkInactive()
    {
        if ($this->user->status_id !== Status::INACTIVE) {
            return true;
        }

        return $this->addAction('Activate', 'check-square-o', $this->makeRoute('activate', 0));
    }
847415
function current()
    {
        if (!isset($this->_curPage)
            || $this->_curPage->getPage() != $this->_position
        ) {
            $this->_curPage = $this->_pages->get($this->_position);
        }
        return $this->_curPage;
    }
480370
public function get_active()
    {
        if ($this->active !== null) {
            return $this->active;
        }

        if (!$this->sieve) {
            return $this->_set_error(self::ERROR_INTERNAL);
        }

        return $this->active = $this->sieve->getActive();
    }
1218547
private function checkPages()
    {
        if (is_null($this->pageLimit)) {
            return false;
        }

        if (++$this->pageCounter > $this->pageLimit) {
            return true;
        }
        return false;
    }
146867
public function is_active() : bool {
        $active = [
            api::DATAREQUEST_STATUS_APPROVED => true,
        ];

        return isset($active[$this->get('status')]);
    }
113805
public function getStatus(): bool
    {
        foreach ($this->requestVersion() as $key => $version) {
            if (! Str::contains($key, 'dev')) {
                continue;
            }

            if (version_compare($version['version'], $this->currentVersion, '>')) {
                return true;
            }
        }

        return false;
    }
1055321
public function is_active() {

		if ( ! empty( $this->struct['screen'] ) && ! in_array( $this->screen->id, (array) $this->struct['screen'] ) ) {
			return false;
		}

		return parent::is_active();
	}
602732
public function active()
    {
        $classes = $this->getAdaptee()->classes;

        foreach ($classes as $class) {
            if (strpos($class, 'current') !== false) {
                return true;
            }
        }

        return false;
    }
235446
public function activeChild()
    {
        $uri = Grav::instance()['uri'];
        $pages = Grav::instance()['pages'];
        $uri_path = rtrim(urldecode($uri->path()), '/');
        $routes = Grav::instance()['pages']->routes();

        if (isset($routes[$uri_path])) {
            /** @var PageInterface $child_page */
            $child_page = $pages->dispatch($uri->route())->parent();
            if ($child_page) {
                while (!$child_page->root()) {
                    if ($this->path() === $child_page->path()) {
                        return true;
                    }
                    $child_page = $child_page->parent();
                }
            }
        }

        return false;
    }
739228
public function isActive()
    {
        $sid = defined('SID') ? constant('SID') : false;
        if ($sid !== false && session_id()) {
            return true;
        }

        if (headers_sent()) {
            return true;
        }

        return false;
    }
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;
	}
493499
public function canHandle(): bool
    {
        if ($this->table !== 'pages') {
            return false;
        }

        if (!$this->backendUser->isAdmin()) {
            return false;
        }

        /** @var $rootPageResolver RootPageResolver */
        $rootPageResolver = GeneralUtility::makeInstance(RootPageResolver::class);
        return $rootPageResolver->getIsRootPageId((int)$this->identifier);
    }
819321
protected function checkActivePage($update = true)
    {
        $request = request();

        $pageSetByRequest     = $request->has('page') || $this->resetActivePage;
        $pageSizeSetByRequest = $request->filled('pagesize');

        if ($update && $pageSetByRequest) {

            $this->activePage = $request->get('page') ? (int) $request->get('page') : null;

        } elseif ($this->getListMemory()->hasPage()) {

            $this->retrieveActivePageFromSession();
        }

        if ($update && $pageSizeSetByRequest) {

            $this->activePageSize = $request->get('pagesize') ? (int) $request->get('pagesize') : null;
            $this->activePage     = null;

        } elseif ($this->getListMemory()->hasPageSize()) {

            $this->retrieveActivePageSizeFromSession();
        }

        if ($update && ($pageSetByRequest || $pageSizeSetByRequest)) {
            $this->storeActivePageValuesInSession();
        }

        return $this;
    }
1227722
public function isActive($recursive = false)
        {
            if (!$this->_active && $recursive) {
                foreach ($this->_pages as $page) {
                    if ($page->isActive(true)) {
                        return true;
                    }
                }

                return false;
            }

            return $this->_active;
        }