Get a collection of installed feature names

@return installed feature name collection
333261
public Collection<String> getInstalledFeatureNames() {
        if (installAssets == null)
            return null;
        Collection<String> installed = new ArrayList<String>();
        for (List<InstallAsset> iaList : installAssets) {
            for (InstallAsset asset : iaList) {
                if (asset.isFeature()) {
                    ESAAsset esa = (ESAAsset) asset;
                    if (esa.isPublic()) {
                        String esaName = esa.getShortName();
                        if (esaName == null || esaName.isEmpty())
                            esaName = esa.getFeatureName();
                        installed.add(esaName);
                    }
                }
            }
        }
        return installed;
    }
1149466
public List<ObjectName> getObjectNames() {
        List<String> names = getMBeanNames();
        List<ObjectName> ret = new ArrayList<ObjectName>(names.size());
        for (String name : names) {
            try {
                ret.add(new ObjectName(name));
            } catch (MalformedObjectNameException e) {
                // Should never happen since the names returned by the server must
                // be valid ObjectNames for sure
                throw new IllegalStateException("Cannot convert search result '" + name + "' to an ObjectName",e);
            }
        }
        return ret;
    }
1171867
public ObjectName[] getComponents()
    {
        Holder[] h=(Holder[])_mbeanMap.values().toArray(new Holder[_mbeanMap.size()]);
        ObjectName[] on = new ObjectName[h.length];
        for (int i=0;i<on.length;i++)
            on[i]=h[i].oName;
        return on;
    }
621629
public synchronized Set<String> getNames() {
        if (map == null) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(map.keySet());
    }
660656
public function getCollectionNames() {

        $stmt   = $this->connection->query("SELECT name FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence';");
        $tables = $stmt->fetchAll( \PDO::FETCH_ASSOC);
        $names  = [];

        foreach ($tables as $table) {
            $names[] = $table['name'];
        }

        return $names;
    }
7885
public Set<String> getResourceNames() {
		Set<String> resourceNames = new HashSet<>();

		if (myNameToResourceDefinition.isEmpty()) {
			Properties props = new Properties();
			try {
				props.load(myVersion.getFhirVersionPropertiesFile());
			} catch (IOException theE) {
				throw new ConfigurationException("Failed to load version properties file");
			}
			Enumeration<?> propNames = props.propertyNames();
			while (propNames.hasMoreElements()) {
				String next = (String) propNames.nextElement();
				if (next.startsWith("resource.")) {
					resourceNames.add(next.substring("resource.".length()).trim());
				}
			}
		}

		for (RuntimeResourceDefinition next : myNameToResourceDefinition.values()) {
			resourceNames.add(next.getName());
		}

		return Collections.unmodifiableSet(resourceNames);
	}
675859
public Set<String> queryFeatureNames() {
        Set<String> result = null;
        try {
            //if you change the 'null' arg, don't forget to implement the exception handler block!
            ServiceReference<?>[] refs = this.systemBundleCtx.getAllServiceReferences(ServerFeatures.class.getName(), null);
            if (refs != null && refs.length > 0) {
                result = new HashSet<String>();
                //if we somehow had more than one eligible service, we will use them all.
                //result will then be the aggregate of all data.
                for (ServiceReference<?> sr : refs) {
                    ServerFeatures sf = (ServerFeatures) this.systemBundleCtx.getService(sr);
                    String infos[] = sf.getServerFeatureNames();
                    for (String info : infos) {
                        result.add(info);
                    }
                }
            }
        } catch (InvalidSyntaxException e) {
            //tough for the filter 'null' to be invalid..
        }

        //sort the list alpha.. just makes it neater to debug missing files..
        ArrayList<String> sorted = new ArrayList<String>();
        if (result != null)
            sorted.addAll(result);
        Collections.sort(sorted);
        result = new LinkedHashSet<String>(); //linked set will preserve order

        //maybe addAll will work here, it's not clear, the intent is to preserve the sorted order.
        for (String s : sorted) {
            result.add(s);
        }
        return result;
    }
378527
public Map<String, AddOperation> getAddOperations() {
    Map<String, AddOperation> addOperations = new TreeMap<String, AddOperation>();
    for (Entry<String, IOperation> entry : collectionUpdateData.entrySet()) {
      String key = entry.getKey();
      IOperation op = entry.getValue();
      if (op.getOperationType().equals(Type.ADD)) {
        AddOperation aop = (AddOperation)op;
        if (null != aop.getDefaultValue()) {
          addOperations.put(key, aop);
        }
      }
    }
    return addOperations;
  }
1359220
@SuppressWarnings("unchecked")
    @Override
    public Collection<FeatureCollectionAsset> getFeatureCollections(String productId, String productVersion, String productInstallType, String productLicenseType,
                                                                    String productEdition) {
        return (Collection<FeatureCollectionAsset>) getEsaAsset(productId, productVersion, productInstallType, productLicenseType, productEdition,
                                                                Visibility.INSTALL);
    }
910986
@InterfaceAudience.Public
    public List<String> getAllDatabaseNames() {
        String[] databaseFiles = directoryFile.list(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String filename) {
                if (filename.endsWith(Manager.kDBExtension)) {
                    return true;
                }
                return false;
            }
        });
        List<String> result = new ArrayList<String>();
        for (String databaseFile : databaseFiles) {
            String trimmed = databaseFile.substring(0, databaseFile.length() - Manager.kDBExtension.length());
            String replaced = trimmed.replace(':', '/');
            result.add(replaced);
        }
        Collections.sort(result);
        return Collections.unmodifiableList(result);
    }
102287
def collection_names
      namespaces = self["system.namespaces"].find(name: { "$not" => /#{name}\.system\.|\$/ })
      namespaces.map do |doc|
        _name = doc["name"]
        _name[name.length + 1, _name.length]
      end
    end
807736
public function getInstalledAddons()
    {
        if (!$this->controller_install_addon) {
            $this->controller_install_addon = $this->add('sandbox\\Controller_InstallAddon');
        }

        if ($this->controller_install_addon && $this->controller_install_addon->getSndBoxAddonReader()) {
            return $this->controller_install_addon->getSndBoxAddonReader()->getReflections();
        }

        return array();
    }
63269
public final Set<String> getPropertyNames() {
    Set<String> props = new TreeSet<>();
    collectPropertyNames(props);
    return props;
  }
15324
public Set<String> getPropertyNames() {
    return Sets.newHashSet(
        Iterables.concat(this.commonProperties.stringPropertyNames(), this.specProperties.stringPropertyNames()));
  }
965901
public List<String> getDirtyBundleNames() {

		List<String> bundleNames = new ArrayList<>();
		if (bundlesHandler != null) {
			bundleNames = bundlesHandler.getDirtyBundleNames();
		}

		return bundleNames;
	}
867550
public Map<String, InstalledFeature> getInstalledCoreFeatures() {
        try {
            Map<String, InstalledFeature> installedFeatures = new TreeMap<String, InstalledFeature>();
            Map<String, ProvisioningFeatureDefinition> fdMap = product.getCoreFeatureDefinitions();
            for (Entry<String, ProvisioningFeatureDefinition> entry : fdMap.entrySet()) {
                installedFeatures.put(entry.getKey(), new InstalledAssetImpl(entry.getValue()));
            }
            return installedFeatures;
        } catch (FeatureToolException rte) {
            log(Level.FINEST, "Director.getInstalledCoreFeatures() got exception.", rte);
            return null;
        }
    }
350798
public Set<String> getConstantNames() {
        return constants.stream()
                .map(EnumConstant::getName)
                .collect(Collectors.toSet());
    }