Gets the status of the indices.

@return Index[]
342412
public function getIndices(): array
    {
        $indices = [];
        foreach ($this->_data['indices'] as $indexName => $index) {
            $indices[$indexName] = new Index($indexName, $index);
        }

        return $indices;
    }
542018
public static function getStatusList()
    {
        // @todo: check for a complete list of available CloudFront statuses
        return [
            self::STATUS_OK => 'Completed',
            self::STATUS_TO_SEND => 'STATUS_TO_SEND',
            self::STATUS_TO_FLUSH => 'STATUS_TO_FLUSH',
            self::STATUS_ERROR => 'STATUS_ERROR',
            self::STATUS_WAITING => 'InProgress',
        ];
    }
834792
private function getTranslatedStatus()
    {
        if ($this->status === null) {
            $this->status = [t('Active'), t('Inactive')];
        }

        return $this->status;
    }
90284
public function getStats()
    {
        if (!$this->enabled)
            return array();

        $stats = @$this->getConnection()->getStats();

        $this->Logger->debug('Retrieved Stats');
        $this->Logger->debug($stats);

        return $stats;
    }
973166
public static function getStatusList()
    {
        return [
            TransactionInterface::STATUS_ORDER_UNKNOWN => 'order_unknown',
            TransactionInterface::STATUS_OPEN => 'open',
            TransactionInterface::STATUS_PENDING => 'pending',
            TransactionInterface::STATUS_VALIDATED => 'validated',
            TransactionInterface::STATUS_CANCELLED => 'cancelled',
            TransactionInterface::STATUS_UNKNOWN => 'status_unknown',
            TransactionInterface::STATUS_ERROR_VALIDATION => 'error_validation',
            TransactionInterface::STATUS_WRONG_CALLBACK => 'wrong_callback',
            TransactionInterface::STATUS_WRONG_REQUEST => 'wrong_request',
            TransactionInterface::STATUS_ORDER_NOT_OPEN => 'order_to_open',
        ];
    }
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;
    }
1347500
public static function getUserStatusList()
    {
        return [
            IdentityInterface::STATUS_FORBIDDEN => Yii::t('wocenter/app', 'User disabled status'),
            IdentityInterface::STATUS_ACTIVE => Yii::t('wocenter/app', 'User active status'),
            IdentityInterface::STATUS_LOCKED => Yii::t('wocenter/app', 'User locked status'),
            IdentityInterface::STATUS_DELETED => Yii::t('wocenter/app', 'User deleted status'),
        ];
    }
1253654
public function getAllTableStatus()
    {
        $this->currentQueryIsMaster = false;
        $stmt = $this->prepare('SHOW TABLE STATUS FROM ' . $this->conf['master']['dbname'], $this->rlink);
        $this->execute($stmt);
        $res = $stmt->fetchAll(\PDO::FETCH_ASSOC);
        $return = [];
        foreach ($res as $val) {
            $return[$val['Name']] = $val;
        }
        return $return;
    }
1013291
static public function getStatuses()
    {
        return [
            self::STATUS_NEW => \Yii::t('skeeks/reviews2', "New"),
            self::STATUS_PROCESSED => \Yii::t('skeeks/reviews2', "In Progress"),
            self::STATUS_ALLOWED => \Yii::t('skeeks/reviews2', "Approved"),
            self::STATUS_CANCELED => \Yii::t('skeeks/reviews2', "Rejected"),
        ];
    }
777383
public function getStat()
    {
        $sources = [];
        $names = [];
        foreach ($this->lines as $line) {
            $line->loadStat($sources, $names);
        }
        return [
            'sources' => $sources,
            'names' => $names,
        ];
    }
1260581
public function listAvailableStates(): array
    {
        if (!empty($this->states) && \is_array($this->states)) {
            return \array_keys($this->states);
        } else {
            return [];
        }
    }
206044
public function getStatus()
    {
        $status_event = $this->call->startBatch([
            OP_RECV_STATUS_ON_CLIENT => true,
        ]);

        $this->trailing_metadata = $status_event->status->metadata;

        return $status_event->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;
    }
891839
public function getStatusAllowableValues()
    {
        return [
            self::STATUS_DRAFT,
            self::STATUS_SENT,
            self::STATUS_ARCHIVE,
            self::STATUS_QUEUED,
            self::STATUS_SUSPENDED,
            self::STATUS_IN_PROCESS,
        ];
    }
926454
public function getIndexQueueMonitoredTables()
    {
        $monitoredTables = [];

        $indexingConfigurations = $this->getEnabledIndexQueueConfigurationNames();
        foreach ($indexingConfigurations as $indexingConfigurationName) {
            $monitoredTable = $this->getIndexQueueTableNameOrFallbackToConfigurationName($indexingConfigurationName);
            $monitoredTables[] = $monitoredTable;
            if ($monitoredTable === 'pages') {
                // when monitoring pages, also monitor creation of translations
                $monitoredTables[] = 'pages_language_overlay';
            }
        }

        return array_values(array_unique($monitoredTables));
    }
393271
public function getStatus()
    {
        $reports = [];

        $rootPageFlagStatus = $this->getRootPageFlagStatus();
        if (!is_null($rootPageFlagStatus)) {
            $reports[] = $rootPageFlagStatus;

            // intended early return, no sense in going on if there are no root pages
            return $reports;
        }

        $domainRecordAvailableStatus = $this->getDomainRecordAvailableStatus();
        if (!is_null($domainRecordAvailableStatus)) {
            $reports[] = $domainRecordAvailableStatus;
        }

        $configIndexEnableStatus = $this->getConfigIndexEnableStatus();
        if (!is_null($configIndexEnableStatus)) {
            $reports[] = $configIndexEnableStatus;
        }

        return $reports;
    }
18575
public function getAllowedStatuses()
    {
        return [
            self::STATUS_CLIENT_DELETE_PROHIBITED,
            self::STATUS_CLIENT_HOLD,
            self::STATUS_CLIENT_RENEW_PROHIBITED,
            self::STATUS_CLIENT_TRANSFER_PROHIBITED,
            self::STATUS_CLIENT_UPDATE_PROHIBITED,
            self::STATUS_INACTIVE,
            self::STATUS_OK,
            self::STATUS_PENDING_CREATE,
            self::STATUS_PENDING_DELETE,
            self::STATUS_PENDING_RENEW,
            self::STATUS_PENDING_TRANSFER,
            self::STATUS_PENDING_UPDATE,
            self::STATUS_SERVER_DELETE_PROHIBITED,
            self::STATUS_SERVER_HOLD,
            self::STATUS_SERVER_RENEW_PROHIBITED,
            self::STATUS_SERVER_TRANSFER_PROHIBITED,
            self::STATUS_SERVER_UPDATE_PROHIBITED,
        ];
    }