Returns a list of loaded app names

@param bool $only_names
Optional flag to switch the return value to be only an array of app names or instances (Default: true)

@return array
515360
public function getLoadedApps(bool $only_names = true)
    {
        if ($only_names) {
            return array_keys($this->apps);
        }

        return $this->apps;
    }
397530
public function getNames(): array
    {
        $enumeration = $this->enumeration;
        $names       = [];
        foreach ($this->getOrdinals() as $ord) {
            $names[] = $enumeration::byOrdinal($ord)->getName();
        }
        return $names;
    }
675722
public static function getApplicationName():?string
    {
        if (self::isCliApp()) {
            return self::$APPLICATION_NAME;
        }

        return MSession::get(MCoreApplication::APPLICATION_NAME);
    }
965263
public static function getAvailableClients()
    {
        $instance = new static();
        $regexes = $instance->getRegexes();
        $names = array();
        foreach ($regexes as $regex) {
            if ($regex['name'] != '$1') {
                $names[] = $regex['name'];
            }
        }

        natcasesort($names);

        return array_unique($names);
    }
719815
public static function registerApps():array
    {
        $classes = self::getClassFile();
        if (count((array)$classes) == 0) {
            throw new Server000(new \ArrayObject(array()));
        }
        $apps = array();
        foreach ($classes as $class => $val) {
            $val = (array)$val;
            $apps[$val['name']] =  array("appclass" => new $val['class'](),
                "enabled" => $val['enabled'], "prefix" => $val['prefix']);
        }
        return $apps;
    }
950484
public function getNames()
    {
        $enums = [];

        foreach (static::toArray() as $name => $value) {
            if ($this->has($value)) {
                $enums[] = $name;
            }
        }

        return $enums;
    }
489706
def get_flagged_names():
    """"""

    l = []
    for w in _widget_cache.values():
        if w.flagged:
            l.append(w.get_node().get_value())
    return l
622899
public function getServiceNamesByType($types, $only_active = false)
    {
        $names = [];
        $map = $this->getServiceNameTypeMap($only_active);
        if (is_string($types)) {
            $types = array_map('trim', explode(',', trim($types, ',')));
        }
        foreach ($map as $name => $type) {
            if (false !== array_search($type, $types)) {
                $names[] = $name;
            }
        }

        return $names;
    }
1103167
def get_apps(self):
        
        ena_apps = {}

        res = self._make_ocs_request('GET', self.OCS_SERVICE_CLOUD, 'apps')
        if res.status_code != 200:
            raise HTTPResponseError(res)
        tree = ET.fromstring(res.content)
        self._check_ocs_status(tree)
        # <data><apps><element>files</element><element>activity</element> ...
        for el in tree.findall('data/apps/element'):
            ena_apps[el.text] = False

        res = self._make_ocs_request('GET', self.OCS_SERVICE_CLOUD,
                                     'apps?filter=enabled')
        if res.status_code != 200:
            raise HTTPResponseError(res)
        tree = ET.fromstring(res.content)
        self._check_ocs_status(tree)
        for el in tree.findall('data/apps/element'):
            ena_apps[el.text] = True

        return ena_apps
1234264
protected function _getVisibleColNames()
    {
        $aColNames = $this->_getColNames();
        $aUserCols = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter('aCols');
        $aVisibleCols = [];

        // user defined some cols to load ?
        if (is_array($aUserCols)) {
            foreach ($aUserCols as $iKey => $sCol) {
                $iCol = ( int ) str_replace('_', '', $sCol);
                if (isset($aColNames[$iCol]) && !$aColNames[$iCol][4]) {
                    $aVisibleCols[$iCol] = $aColNames[$iCol];
                }
            }
        }

        // no user defined valid cols ? setting defauls ..
        if (!count($aVisibleCols)) {
            foreach ($aColNames as $sName => $aCol) {
                // visible ?
                if ($aCol[1] && !$aColNames[$sName][4]) {
                    $aVisibleCols[$sName] = $aCol;
                }
            }
        }

        return $aVisibleCols;
    }
541163
public static String[] getAvailableStatusNames() {
    List<String> nameList = new ArrayList<>();
    for (Status status : INSTANCES.values()) {
      nameList.add(status.getName());
    }
    return nameList.toArray(new String[nameList.size()]);
  }
616093
public function getAppRoutes()
    {
        $key = __METHOD__;
//        $cache = Configs::instance()->cache;
        $cache = null;
        if ($cache === null || ($result = $cache->get($key)) === false) {
            $result = [];
            $this->getRouteRecrusive(Yii::$app, $result);
            if ($cache !== null) {
                $cache->set($key, $result, Configs::instance()->cacheDuration, new TagDependency([
                    'tags' => self::CACHE_TAG
                ]));
            }
        }

        return $result;
    }
32636
protected static function _getTagList() {
        $config = Zend_Registry::get('config');
        if (!empty($config->staticcaching->tags)) {
            return $config->staticcaching->tags;
        }

        // For backward-compatibility: fall back to a separate cache.ini
        $ini = new Garp_Config_Ini(APPLICATION_PATH . '/configs/cache.ini', APPLICATION_ENV);
        if (!empty($ini->tags)) {
            return $ini->tags;
        }

        return null;
    }
660041
def get_public_cms_app_namespaces():
    
    qs = Page.objects.public()
    qs = qs.exclude(application_namespace=None)
    qs = qs.order_by('application_namespace')

    try:
        application_namespaces = list(
            qs.distinct('application_namespace').values_list(
                'application_namespace', flat=True))
    except NotImplementedError:
        # If SQLite used:
        #   DISTINCT ON fields is not supported by this database backend
        application_namespaces = list(
            set(qs.values_list('application_namespace', flat=True)))

    application_namespaces.sort()

    return tuple(application_namespaces)
980213
public static function getSimpleAppFormat(array $apps):array
    {
        $narray = array();
        foreach ($apps as $oneapp => $val) {
            $e = AppConfig::getInstance($oneapp);
            if ($e->checkVisibility()) {
                array_push($narray, array("name" => $oneapp, "value" => $val));
            }
        }
        return ($narray);
    }
1259782
static function getList()
    {
        $list = new \BearFramework\DataList();
        foreach (self::$data as $addon) {
            $list[] = clone($addon);
        }
        return $list;
    }
849613
public function getActiveViewsNames()
    {
        $names = [];

        if (is_array($this->getActiveViewsList())) {
            foreach ($this->getActiveViewsList() as $view) {
                $names[] = $view->getClassName();
            }
        }

        return $names;
    }