/ @returns The status flags for the query.
180299
public Result<List<Long>> finalizeSlicedFindPath() {

        List<Long> path = new ArrayList<>(64);
        if (m_query.status.isFailed()) {
            // Reset query.
            m_query = new QueryData();
            return Result.failure(path);
        }

        if (m_query.startRef == m_query.endRef) {
            // Special case: the search starts and ends at same poly.
            path.add(m_query.startRef);
        } else {
            // Reverse the path.
            if (m_query.lastBestNode.id != m_query.endRef) {
                m_query.status = Status.PARTIAL_RESULT;
            }

            Node prev = null;
            Node node = m_query.lastBestNode;
            int prevRay = 0;
            do {
                Node next = m_nodePool.getNodeAtIdx(node.pidx);
                node.pidx = m_nodePool.getNodeIdx(prev);
                prev = node;
                int nextRay = node.flags & Node.DT_NODE_PARENT_DETACHED; // keep track of whether parent is not adjacent
                                                                         // (i.e. due to raycast shortcut)
                node.flags = (node.flags & ~Node.DT_NODE_PARENT_DETACHED) | prevRay; // and store it in the reversed
                                                                                     // path's node
                prevRay = nextRay;
                node = next;
            } while (node != null);

            // Store path
            node = prev;
            do {
                Node next = m_nodePool.getNodeAtIdx(node.pidx);
                if ((node.flags & Node.DT_NODE_PARENT_DETACHED) != 0) {
                    Result<RaycastHit> iresult = raycast(node.id, node.pos, next.pos, m_query.filter, 0, 0);
                    if (iresult.succeeded()) {
                        path.addAll(iresult.result.path);
                    }
                    // raycast ends on poly boundary and the path might include the next poly boundary.
                    if (path.get(path.size() - 1) == next.id) {
                        path.remove(path.size() - 1); // remove to avoid duplicates
                    }
                } else {
                    path.add(node.id);
                }

                node = next;
            } while (node != null);
        }

        Status status = m_query.status;
        // Reset query.
        m_query = new QueryData();

        return Result.of(status, path);
    }
245310
public function getPortStatus()
    {
        $status = $this->portConfig;
        foreach ($status as &$value) {
            $value['fdcount'] = 0;
        }
        foreach (get_instance()->server->connections as $fd) {
            $port = get_instance()->getServerPort($fd);
            if (array_key_exists($port, $status)) {
                $status[$port]['fdcount']++;
            }
        }
        return $status;
    }
925147
public function getStatus()
    {
        $reports = [];
        $solrConnections = GeneralUtility::makeInstance(ConnectionManager::class)->getAllConnections();

        foreach ($solrConnections as $solrConnection) {
            $adminService = $solrConnection->getAdminService();
            if ($adminService->ping()) {
                $installationStatus = $this->checkPluginInstallationStatus($adminService);
                $versionStatus = $this->checkPluginVersion($adminService);

                if (!is_null($installationStatus)) {
                    $reports[] = $installationStatus;
                }

                if (!is_null($versionStatus)) {
                    $reports[] = $versionStatus;
                }
            }
        }

        return $reports;
    }
250217
public function getStatus()
    {

        $info_array                 = array();
        $info_array ['status']      = parent::getStats();
        $info_array ['version']     = parent::getVersion();
        $info_array ['server_list'] = parent::getServerList();

        return $info_array;
    }
89409
public function updateStatusFlags(&$flags)
    {
        // If there is no current FluentState, then we shouldn't update.
        if (!FluentState::singleton()->getLocale()) {
            return;
        }

        // If this page does not exist it should be "invisible"
        if (!$this->isDraftedInLocale() && !$this->isPublishedInLocale()) {
            $flags['fluentinvisible'] = [
                'text' => '',
                'title' => '',
            ];
        }
    }
94671
public function getStatusDescription()
    {
        static $list = null;
        if ($list === null) {
            $list = static::getStatuses();
        }
        return (isset($list[$this->status])) ? $list[$this->status] : $this->status;
    }
252635
def get_flags():
    
    flags = unitdata.kv().getrange('reactive.states.', strip=True) or {}
    return sorted(flags.keys())
182755
public static function getStatusList($withLabelsAsIndexes = false, array $filterStatus = null)
    {
        // Build $statusValues if this is the first call
        if (null === static::$statusValues) {
            static::$statusValues = array();
            $refClass = new \ReflectionClass(get_called_class());
            $classConstants = $refClass->getConstants();
            $className = $refClass->getShortName();

            $constantPrefix = 'STATUS_';
            foreach ($classConstants as $key => $val) {
                if (substr($key, 0, strlen($constantPrefix)) === $constantPrefix) {
                    static::$statusValues[$val] = static::getLowerCaseClassName().'.status.'.$val;
                }
            }
        }

        $statusValues = static::$statusValues;

        // Filter on specified status list
        if (isset($filterStatus)) {
            $statusValues = array_filter($statusValues, function ($key) use ($filterStatus) {
                return in_array($key, $filterStatus);
            }, ARRAY_FILTER_USE_KEY);
        }

        if ($withLabelsAsIndexes) {
            return array_flip($statusValues);
        }

        return array_keys($statusValues);
    }
1078036
public static function getStatusList()
    {
        return [
            self::STATUS_OK => 'ok',
            self::STATUS_SENDING => 'sending',
            self::STATUS_PENDING => 'pending',
            self::STATUS_ERROR => 'error',
            self::STATUS_ENCODING => 'encoding',
        ];
    }
1271105
protected function getRootPageFlagStatus()
    {
        $rootPages = $this->getRootPages();
        if (!empty($rootPages)) {
            return null;
        }

        $report = $this->getRenderedReport('RootPageFlagStatus.html');
        return GeneralUtility::makeInstance(
            Status::class,
            /** @scrutinizer ignore-type */ 'Sites',
            /** @scrutinizer ignore-type */ 'No sites found',
            /** @scrutinizer ignore-type */ $report,
            /** @scrutinizer ignore-type */ Status::ERROR
        );
    }
57363
public function getAllowedStatuses()
    {
        return [
            self::STATUS_CLIENT_DELETE_PROHIBITED,
            self::STATUS_CLIENT_TRANSFER_PROHIBITED,
            self::STATUS_CLIENT_UPDATE_PROHIBITED,
            self::STATUS_LINKED,
            self::STATUS_OK,
            self::STATUS_PENDING_CREATE,
            self::STATUS_PENDING_DELETE,
            self::STATUS_PENDING_TRANSFER,
            self::STATUS_PENDING_UPDATE,
            self::STATUS_SERVER_DELETE_PROHIBITED,
            self::STATUS_SERVER_TRANSFER_PROHIBITED,
            self::STATUS_SERVER_UPDATE_PROHIBITED,
        ];
    }
51064
public function getStatus()
    {
        /** @var $result CallResult */
        $result = $this->getGit()->{'status'}($this->getRepositoryPath(), array(
            '--short'
        ));
        $result->assertSuccess(
            sprintf('Cannot retrieve status from "%s"', $this->getRepositoryPath())
        );

        $output = rtrim($result->getStdOut());
        if (empty($output)) {
            return array();
        }

        $status = array_map(function($f) {
            $line   = rtrim($f);
            $parts  = array();
            preg_match('/^(?<x>.)(?<y>.)\s(?<f>.+?)(?:\s->\s(?<f2>.+))?$/', $line, $parts);

            $status = array(
                'file'      => $parts['f'],
                'x'         => trim($parts['x']),
                'y'         => trim($parts['y']),
                'renamed'   => (array_key_exists('f2', $parts)) ? $parts['f2'] : null
            );
            return $status;
        }, explode("\n", $output));
        return $status;
    }
214574
def get_system_flags() -> FrozenSet[Flag]:
    """"""
    return frozenset({Seen, Recent, Deleted, Flagged, Answered, Draft})
862788
public function getStatuses()
	{
		// Fetch statuses when the method is called for the first time.
		if ( $this->statuses === null ) {
			$statuses = array();
			$result = $this->api(self::REQUEST_GET, '/rest/api/2/status', array(), true);

			/* set hash key as custom field id */
			foreach ( $result as $status ) {
				$statuses[$status['id']] = $status;
			}

			$this->statuses = $statuses;
		}

		return $this->statuses;
	}
264736
public static Status getStatus(String pdbId) {
		Status[] statuses = getStatus(new String[] {pdbId});
		if(statuses != null) {
			assert(statuses.length == 1);
			return statuses[0];
		} else {
			return null;
		}
	}
526410
public function getStatus()
    {
        $statuses = array();

        $statuses['core_version'] = array(
            'title' => $this->translation->text('Core version'),
            'description' => '',
            'severity' => 'info',
            'status' => gplcart_version(),
            'weight' => 0,
        );

        $statuses['database_version'] = array(
            'title' => $this->translation->text('Database version'),
            'description' => '',
            'severity' => 'info',
            'status' => $this->db->getPdo()->getAttribute(\PDO::ATTR_SERVER_VERSION),
            'weight' => 1,
        );

        $statuses['php_version'] = array(
            'title' => $this->translation->text('PHP version'),
            'description' => '',
            'severity' => 'info',
            'status' => PHP_VERSION,
            'weight' => 2,
        );

        $statuses['php_os'] = array(
            'title' => $this->translation->text('PHP operating system'),
            'description' => '',
            'severity' => 'info',
            'status' => PHP_OS,
            'weight' => 3,
        );

        $statuses['php_memory_limit'] = array(
            'title' => $this->translation->text('PHP Memory Limit'),
            'description' => '',
            'severity' => 'info',
            'status' => ini_get('memory_limit'),
            'weight' => 4,
        );

        $statuses['php_apc_enabled'] = array(
            'title' => $this->translation->text('PHP APC cache enabled'),
            'description' => '',
            'severity' => 'info',
            'status' => ini_get('apc.enabled') ? $this->translation->text('Yes') : $this->translation->text('No'),
            'weight' => 5,
        );

        $statuses['server_software'] = array(
            'title' => $this->translation->text('Server software'),
            'description' => '',
            'severity' => 'info',
            'status' => filter_input(INPUT_SERVER, 'SERVER_SOFTWARE', FILTER_SANITIZE_STRING),
            'weight' => 6
        );

        $date_format = $this->config->get('date_full_format', 'd.m.Y H:i');

        $statuses['cron'] = array(
            'title' => $this->translation->text('Cron last run'),
            'description' => '',
            'severity' => 'info',
            'status' => date($date_format, $this->config->get('cron_last_run')),
            'weight' => 7,
        );

        $filesystem = $this->checkFilesystem();

        $statuses['filesystem'] = array(
            'title' => $this->translation->text('Filesystem is protected'),
            'description' => '',
            'severity' => 'danger',
            'status' => $filesystem === true ? $this->translation->text('Yes') : $this->translation->text('No'),
            'details' => $filesystem === true ? array() : $filesystem,
            'weight' => 8,
        );

        $statuses['search_index'] = array(
            'title' => $this->translation->text('Search index'),
            'description' => '',
            'severity' => 'info',
            'status' => $this->translation->text('@num rows', array('@num' => $this->countSearchIndex())),
            'weight' => 9,
        );

        $this->hook->attach('report.statuses', $statuses, $this);

        gplcart_array_sort($statuses);
        return $statuses;
    }
872115
protected function getFlags()
    {
        return array(
            ExtractorInterface::FLAG_DEPLOYED,
            ExtractorInterface::FLAG_DEPLOYING,
            ExtractorInterface::FLAG_DODEPLOY,
            ExtractorInterface::FLAG_FAILED,
            ExtractorInterface::FLAG_UNDEPLOYED,
            ExtractorInterface::FLAG_UNDEPLOYING
        );
    }