Gets the names of assets inside installAssets

@return Map of asset types and collections of asset names
350144
public Map<String, Collection<String>> getInstalledAssetNames() {
        if (installAssets == null)
            return null;
        Map<String, Collection<String>> installed = new HashMap<String, Collection<String>>();
        Collection<String> installedAddons = new ArrayList<String>();
        Collection<String> installedFeatures = new ArrayList<String>();
        Collection<String> installedFixes = new ArrayList<String>();
        Collection<String> installedSamples = new ArrayList<String>();
        Collection<String> installedOpenSources = 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();
                        if (esa.isAddon())
                            installedAddons.add(esaName);
                        else
                            installedFeatures.add(esaName);
                    }
                } else if (asset.isFix()) {
                    installedFixes.add(asset.toString());
                } else if (asset.isSample()) {
                    installedSamples.add(asset.toString());
                } else if (asset.isOpenSource()) {
                    installedOpenSources.add(asset.toString());
                }
            }
        }
        installed.put(InstallConstants.ADDON, installedAddons);
        installed.put(InstallConstants.FEATURE, installedFeatures);
        installed.put(InstallConstants.IFIX, installedFixes);
        installed.put(InstallConstants.SAMPLE, installedSamples);
        installed.put(InstallConstants.OPENSOURCE, installedOpenSources);
        return installed;
    }
1049428
public java.util.List<String> getAnalysisSchemeNames() {
        if (analysisSchemeNames == null) {
            analysisSchemeNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return analysisSchemeNames;
    }
124926
public List<AddOn> getInstalledAddOns() {
        List<AddOn> installedAddOns = new ArrayList<>(addOns.size());
        for (AddOn addOn : addOns) {
            if (AddOn.InstallationStatus.INSTALLED == addOn.getInstallationStatus()) {
                installedAddOns.add(addOn);
            }
        }
        return installedAddOns;
    }
707007
public com.google.api.ads.adwords.axis.v201809.cm.AssetPolicySummaryInfo getAssetPolicySummaryInfo() {
        return assetPolicySummaryInfo;
    }
867125
public File getCoreAssetDir() {
        File assetDir = null;
        File installDir = Utils.getInstallDir();
        if (installDir != null) {
            assetDir = new File(installDir, ASSET_DIR);
        }
        if (assetDir == null) {
            throw new RuntimeException("Asset Directory not found");
        }
        return assetDir;
    }
1374065
public function getAssetFileList()
    {
        $propertyList = $this->_getEntityList('Files');
        $result = [];

        foreach ($propertyList as $properties) {
            $result[] = AssetFile::createFromOptions($properties);
        }

        return $result;
    }
280826
public function getAssetVariables()
    {
        $result = [];

        foreach ($this->getFormFields() as $attribute => $field) {
            if (!$varName = array_get($field, 'assetVar')) {
                continue;
            }

            $result[$varName] = $this->{$attribute};
        }

        return $result;
    }
17698
public function getAssetPaths()
    {
        $this->removeDuplicates();

        $assets = [];
        foreach ($this->assets as $type => $collection) {
            $assets[$type] = [];
            foreach ($collection as $asset) {
                $assets[$type][] = $this->getAssetEntryBuildPath($asset);
            }
        }

        return $assets;
    }
941334
public Set<StringTextValue<?>> asSet()
	{
		final Set<StringTextValue<?>> allSettings = new HashSet<>();
		allSettings.add(getContext());
		allSettings.add(getDir1());
		allSettings.add(getDir2());
		allSettings.add(getPush());
		allSettings.add(getSpacing1());
		allSettings.add(getSpacing2());
		return allSettings;
	}
601378
public Map<String, Class<?>> getPayloadPropertyNames(Map<String,Class<?>> mapPropertyNames)
    {
        mapPropertyNames= super.getPayloadPropertyNames(mapPropertyNames);
        if (m_messageDataDescChildren != null)
        {
            for (String strKey : m_messageDataDescChildren.keySet())
            {
                MessageDataDesc messageDataDesc = m_messageDataDescChildren.get(strKey);
                mapPropertyNames = messageDataDesc.getPayloadPropertyNames(mapPropertyNames);
            }
        }
        return mapPropertyNames;
    }
769672
public function getAssetURL()
    {
        if (!$this->assetHasBeenMapped) {
            $this->mapAssetLocation($this->location);
        }
        $result = $this->assetURL;
        if ($result && $this->isAssetLocal() && !preg_match('/\?(.*&)?' . preg_quote(static::OUTPUT_NOCACHE_PARAM, '/') . '=/', $result)) {
            if ($this->pkg) {
                $noCacheValue = $this->pkg->getPackageVersion();
            } else {
                $app = Application::getFacadeApplication();
                $config = $app->make('config');
                $noCacheValue = $config->get('concrete.version_installed') . '-' . $config->get('concrete.version_db');
            }
            $noCacheValue = $this->obfuscateNoCacheValue($noCacheValue);
            $result .= (strpos($result, '?') === false ? '?' : '&') . static::OUTPUT_NOCACHE_PARAM . '=' . rawurlencode($noCacheValue);
        }

        return $result;
    }
800023
public function getAssetFilesConfiguration()
    {
        if (!$this->assetFilesConfiguration instanceof \AssetsBundle\AssetFile\AssetFilesConfiguration) {
            $this->setAssetFilesConfiguration(new \AssetsBundle\AssetFile\AssetFilesConfiguration());
        }
        return $this->assetFilesConfiguration;
    }
1099298
def get_assets(dstore):
    
    assetcol = dstore['assetcol']
    tagnames = sorted(assetcol.tagnames)
    tag = {t: getattr(assetcol.tagcol, t) for t in tagnames}
    dtlist = [('asset_ref', (bytes, 100))]
    for tagname in tagnames:
        dtlist.append((tagname, (bytes, 100)))
    dtlist.extend([('lon', F32), ('lat', F32)])
    asset_data = []
    for aref, a in zip(assetcol.asset_refs, assetcol.array):
        tup = tuple(b'"%s"' % tag[t][a[t]].encode('utf-8') for t in tagnames)
        asset_data.append((aref,) + tup + (a['lon'], a['lat']))
    return numpy.array(asset_data, dtlist)
617197
protected function getAssetVersions() {
        if (!$this->_assetVersions) {
            $this->_assetVersions = new AssetVersionList(
                $this->version,
                $this->solution['serviceSid'],
                $this->solution['sid']
            );
        }

        return $this->_assetVersions;
    }
833642
public static function collectFieldAssets()
    {
        if (!empty(static::$collectedAssets)) {
            return static::$collectedAssets;
        }

        $css = collect();
        $js = collect();

        foreach (static::$availableFields as $field) {
            if (!method_exists($field, 'getAssets')) {
                continue;
            }

            $assets = call_user_func([$field, 'getAssets']);

            $css->push(array_get($assets, 'css'));
            $js->push(array_get($assets, 'js'));
        }

        return static::$collectedAssets = [
            'css' => $css->flatten()->unique()->filter()->toArray(),
            'js' => $js->flatten()->unique()->filter()->toArray(),
        ];
    }
635342
private void downloadAssets(Map<String, List<List<RepositoryResource>>> installResources, String toExtension) throws InstallException {
        if (installResources == null || installResources.isEmpty()) {
            this.installAssets = new ArrayList<List<InstallAsset>>(1);
            return;
        } else {
            this.installAssets = new ArrayList<List<InstallAsset>>(installResources.size());
        }
        int progress = 10;
        int interval1 = installResources.size() == 0 ? 40 : 40 / installResources.size();
        for (Entry<String, List<List<RepositoryResource>>> targetList : installResources.entrySet()) {
            int interval2 = targetList.getValue().size() == 0 ? interval1 : interval1 / targetList.getValue().size();
            for (List<RepositoryResource> mrList : targetList.getValue()) {
                List<InstallAsset> iaList = new ArrayList<InstallAsset>(mrList.size());
                this.installAssets.add(iaList);
                int interval3 = mrList.size() == 0 ? interval2 : interval2 / mrList.size();
                for (RepositoryResource installResource : mrList) {
                    if (InstallUtils.isDirectoryBasedRepository(installResource))
                        fireDownloadProgressEvent(progress, installResource);
                    progress += interval3;
                    File d = InstallUtils.getFileDirectoryBasedRepository(installResource);
                    if (installResource.getType().equals(ResourceType.FEATURE)) {
                        EsaResource esa = (EsaResource) installResource;
                        ESAAsset esaAsset;
                        String target = targetList.getKey();
                        try {
                            if (d != null) {
                                esaAsset = new ESAAsset(esa.getName(), esa.getProvideFeature(), InstallUtils.toExtension(target, toExtension), d, false);
                                if (esaAsset.getSubsystemEntry() == null) {
                                    throw ExceptionUtils.create(Messages.PROVISIONER_MESSAGES.getLogMessage("tool.install.content.no.subsystem.manifest"),
                                                                InstallException.BAD_FEATURE_DEFINITION);
                                }
                                ProvisioningFeatureDefinition fd = esaAsset.getProvisioningFeatureDefinition();
                                if (!fd.isSupportedFeatureVersion()) {
                                    throw ExceptionUtils.create(Messages.PROVISIONER_MESSAGES.getLogMessage("UNSUPPORTED_FEATURE_VERSION", fd.getFeatureName(),
                                                                                                            fd.getIbmFeatureVersion()),
                                                                InstallException.BAD_FEATURE_DEFINITION);
                                }
                            } else {
                                esaAsset = new ESAAsset(esa.getName(), esa.getProvideFeature(), InstallUtils.toExtension(target, toExtension), esa);
                            }
                            iaList.add(esaAsset);
                        } catch (Exception e) {
                            throw ExceptionUtils.createByKey(e, "ERROR_INVALID_ESA", esa.getName());
                        }
                    } else if (installResource.getType().equals(ResourceType.IFIX)) {
                        try {
                            if (d != null)
                                iaList.add(new FixAsset(installResource.getName(), d, false));
                            else
                                iaList.add(new FixAsset(installResource.getName(), (IfixResource) installResource));
                        } catch (Exception e) {
                            throw ExceptionUtils.createByKey(e, "ERROR_INVALID_IFIX", installResource.getName());
                        }
                    } else if (installResource.getType().equals(ResourceType.PRODUCTSAMPLE)) {
                        try {
                            if (d != null)
                                iaList.add(new SampleAsset(installResource.getName(), ((SampleResource) installResource).getShortName(), d, false));
                            else
                                iaList.add(new SampleAsset((SampleResource) installResource));
                        } catch (Exception e) {
                            throw ExceptionUtils.createByKey(e, "ERROR_INVALID_SAMPLE", installResource.getName());
                        }
                    } else if (installResource.getType().equals(ResourceType.OPENSOURCE)) {
                        try {
                            if (d != null)
                                iaList.add(new OpenSourceAsset(installResource.getName(), ((SampleResource) installResource).getShortName(), d, false));
                            else
                                iaList.add(new OpenSourceAsset((SampleResource) installResource));
                        } catch (Exception e) {
                            throw ExceptionUtils.createByKey(e, "ERROR_INVALID_OPENSOURCE", installResource.getName());
                        }
                    }
                }
            }
        }
    }
153020
function getAssets(reportOptions) {
  const { assetsDir, cdn, dev, inlineAssets, reportDir } = reportOptions;
  const relativeAssetsDir = path.relative(reportDir, assetsDir);

  // Default URLs to assets path
  const assets = {
    inlineScripts: null,
    inlineStyles: null,
    scriptsUrl: path.join(relativeAssetsDir, 'app.js'),
    stylesUrl: path.join(relativeAssetsDir, 'app.css')
  };

  // If using inline assets, load files and strings
  if (inlineAssets) {
    assets.inlineScripts = loadFile(path.join(distDir, 'app.js'));
    assets.inlineStyles = loadFile(path.join(distDir, 'app.inline.css'));
  }

  // If using CDN, return remote urls
  if (cdn) {
    assets.scriptsUrl = `https://unpkg.com/mochawesome-report-generator@${pkg.version}/dist/app.js`;
    assets.stylesUrl = `https://unpkg.com/mochawesome-report-generator@${pkg.version}/dist/app.css`;
  }

  // In DEV mode, return local urls
  if (dev) {
    assets.scriptsUrl = 'http://localhost:8080/app.js';
    assets.stylesUrl = 'http://localhost:8080/app.css';
  }

  // Copy the assets if needed
  if (!dev && !cdn && !inlineAssets) {
    copyAssets(reportOptions);
  }

  return assets;
}