Returns an array of the pageUids in the rootline.

@return array
769543
public function getParentPageIds()
    {
        $rootLineParentPageIds = [];
        if (empty($this->rootLineArray)) {
            // no rootline given
            return $rootLineParentPageIds;
        }

        foreach ($this->rootLineArray as $pageRecord) {
            $rootLineParentPageIds[] = $pageRecord['uid'];
            if (Site::isRootPage($pageRecord)) {
                break;
            }
        }

        return $rootLineParentPageIds;
    }
391138
public static function getRootPageList()
    {
        static $cache = null;

        if ($cache === null) {
            $query = 'SELECT uid,
                             pid,
                             title
                        FROM pages
                       WHERE is_siteroot = 1
                         AND deleted = 0';
            $cache = DatabaseUtility::getAllWithIndex($query, 'uid');
        }

        return $cache;
    }
1217155
public function getAnchors()
    {
        $list = ArrayList::create();
        
        if ($page = $this->getCurrentPage(Page::class)) {
            
            $html = HTMLValue::create($page->Content);
            
            $anchors = $html->query("//*[@id]");
            
            foreach ($anchors as $anchor) {
                
                $list->push(
                    ArrayData::create([
                        'Link' => $page->Link(sprintf('#%s', $anchor->getAttribute('id'))),
                        'Text' => $anchor->textContent
                    ])
                );
                
            }
            
        }
        
        return $list;
    }
642990
protected function getPageTypes()
    {
        $pageTypes = array();
        foreach (SiteTree::page_type_classes() as $pageTypeClass) {
            $pageTypes[$pageTypeClass] = SiteTree::singleton($pageTypeClass)->i18n_singular_name();
        }
        asort($pageTypes);
        return $pageTypes;
    }
839064
public function getPages(): array
    {
        if ($this->_pages !== null) {
            return $this->_pages;
        }

        $this->_pages = [];
        $pages = explode('<!--pagebreak-->', (string)$this);

        foreach ($pages as $page) {
            $this->_pages[] = new \Twig_Markup($page, Craft::$app->charset);
        }

        return $this->_pages;
    }
319005
public static function getAvailableOrigins()
	{
		$arrOrigins = [];

		if(!\Config::get('bypassCache'))
		{
			// Try to get the cache key from the mapper array
			if (file_exists(TL_ROOT . '/system/cache/config/origins.php'))
			{
				$arrOrigins = include TL_ROOT . '/system/cache/config/origins.php';
				return $arrOrigins;
			}
		}


		$objRootPages = \PageModel::findPublishedRootPages();

		if($objRootPages !== null)
		{
			while($objRootPages->next())
			{
				if($objRootPages->dns == '')
				{
					continue;
				}

				$strDomain = $objRootPages->useSSL ? 'https://' : 'http://';
				$strDomain .= $objRootPages->dns;
				$arrOrigins[$objRootPages->id] = $strDomain;
			}
		}

		if(!\Config::get('bypassCache'))
		{
			// Generate the page mapper file
			$objCacheFile = new \File('system/cache/config/origins.php', true);
			$objCacheFile->write(sprintf("<?php\n\nreturn %s;\n", var_export($arrOrigins, true)));
			$objCacheFile->close();
		}

		return $arrOrigins;
	}
753544
protected function _getCurrentPages()
    {
        $ret = array();
        $p = $this->getData()->getPage();
        while ($p) {
            $ret[] = $p;
            $p = $p->getParentPage();
        }
        return $ret;
    }
305684
public static function getAllUidList()
    {
        $data = static::select(array('uid'));
        $uid_map = array();
        foreach ($data as $local_ip => $buffer_array) {
            foreach ($buffer_array as $local_port => $items) {
                //$items = ['connection_id'=>['uid'=>x, 'group'=>[x,x..], 'session'=>[..]], 'client_id'=>[..], ..];
                foreach ($items as $connection_id => $info) {
                    if (!empty($info['uid'])) {
                        $uid_map[$info['uid']] = $info['uid'];
                    }
                }
            }
        }
        return $uid_map;
    }
526109
protected function getIDListFromDB() : array
    {
        switch ($this->sValue) {
            case PromoBlockListStore::SORT_DATE_BEGIN_ASC:
                $arElementIDList = $this->getByDateBeginASC();
                break;
            case PromoBlockListStore::SORT_DATE_BEGIN_DESC:
                $arElementIDList = $this->getByDateBeginDESC();
                break;
            case PromoBlockListStore::SORT_DATE_END_ASC:
                $arElementIDList = $this->getByDateEndASC();
                break;
            case PromoBlockListStore::SORT_DATE_END_DESC:
                $arElementIDList = $this->getByDateEndDESC();
                break;
            case PromoBlockListStore::SORT_DEFAULT:
                $arElementIDList = $this->getBySortOrder();
                break;
            default:
                $arElementIDList = $this->getCustomSortingList();
                break;
        }

        return $arElementIDList;
    }
1337159
public function getPageTypes($dc)
    {
        $options = [];
        $rootAllowed = true;

        if ($dc->activeRecord->pid > 0) {
            $rootAllowed = false;
            $parentType = $this->db->fetchColumn('SELECT type FROM tl_page WHERE id=?', [$dc->activeRecord->pid]);

            // Allow root in second level if the parent is folder
            if ($parentType === 'folder') {
                $rootAllowed = true;
            }
        }

        foreach (array_keys($GLOBALS['TL_PTY']) as $pty) {
            // Root pages are allowed on the first level only (see #6360)
            if ($pty === 'root' && !$rootAllowed) {
                continue;
            }

            // Allow the currently selected option and anything the user has access to
            if ($pty === $dc->value || $this->user->hasAccess($pty, 'alpty')) {
                $options[] = $pty;
            }
        }

        return $options;
    }
713729
public function getIds()
    {
        $res = array();
        $array = wincache_ucache_info();
        $records = $array['ucache_entries'];
        foreach ($records as $record) {
            $res[] = $record['key_name'];
        }
        return $res;
    }
701721
public function getCMSFields()
    {
        $fields = parent::getCMSFields();
        $fields->addFieldsToTab(
            "Root.Main",
            array(
                DropdownField::create(
                    'FormPageID',
                    'Select a page',
                    UserDefinedForm::get()->map('ID', 'Title')
                )
            )
        );

        $this->extend('updateCMSFields', $fields);

        return $fields;
    }
477736
public function getVariables()
    {
        $variables = [];

        if ($this->page->getId()) {
            $variables['cms.identifier'] = $this->page->getIdentifier();
            $variables['cms.title']      = $this->page->getTitle();
        }

        return $variables;
    }
746158
public function getAppliedSets()
	{
		$list = ArrayList::create();
		if (!$this->owner->InheritBlockSets) {
			return $list;
		}

		$sets = BlockSet::get()->where("(PageTypesValue IS NULL) OR (PageTypesValue LIKE '%:\"{$this->owner->ClassName}%')");
		$ancestors = $this->owner->getAncestors()->column('ID');

		foreach ($sets as $set) {
			$restrictedToParerentIDs = $set->PageParents()->column('ID');
			if (count($restrictedToParerentIDs)) {
				// check whether the set should include selected parent, in which case check whether
				// it was in the restricted parents list. If it's not, or if include parentpage
				// wasn't selected, we check the ancestors of this page.
				if ($set->IncludePageParent && in_array($this->owner->ID, $restrictedToParerentIDs)) {
					$list->add($set);
				} else {
					if (count($ancestors)) {
						foreach ($ancestors as $ancestor) {
							if (in_array($ancestor, $restrictedToParerentIDs)) {
								$list->add($set);
								continue;
							}
						}
					}
				}
			} else {
				$list->add($set);
			}
		}

		return $list;
	}
182778
public function getHeaders()
    {
        $headers = $this->header;
        $headers[] = 'User-Agent: ' . $this->getUserAgent();
        $itemId = $this->indexQueueItem->getIndexQueueUid();
        $pageId = $this->indexQueueItem->getRecordPageId();

        $indexerRequestData = [
            'requestId' => $this->requestId,
            'item' => $itemId,
            'page' => $pageId,
            'actions' => implode(',', $this->actions),
            'hash' => md5(
                $itemId . '|' .
                $pageId . '|' .
                $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey']
            )
        ];

        $indexerRequestData = array_merge($indexerRequestData, $this->parameters);
        $headers[] = 'X-Tx-Solr-Iq: ' . json_encode($indexerRequestData, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_AMP | JSON_HEX_QUOT | JSON_UNESCAPED_SLASHES);

        return $headers;
    }
456481
public function getClasses()
    {
        $owner = $this->owner;
        $classes = array();
        $classes[] = $owner->ClassName;
        if ($owner->ClassName == 'PlaceablePage') {
            $classes[] = $owner->PageType()->Type;
        }
        $owner->extend('updateClasses', $classes);
        return implode(' ', $classes);
    }
777285
public function getIds(): array {
        $ids  = array($this->id);
        $meta = $this->getMetadata();
        foreach ($meta->allResources(RC::idProp()) as $id) {
            $ids[] = $id->getUri();
        }
        $ids = array_unique($ids);
        return $ids;
    }