Retrieves a Map of feature definitions in default usr product extension location

@return Null if the user directory cannot be found. An empty map if the features manifests cannot
be found. A Map of product extension features if all goes well.
356287
private Map<String, ProvisioningFeatureDefinition> getUsrProductFeatureDefinitions() {
        Map<String, ProvisioningFeatureDefinition> features = null;
        File userDir = Utils.getUserDir();
        if (userDir != null && userDir.exists()) {
            File userFeatureDir = new File(userDir, USER_FEATURE_DIR);
            if (userFeatureDir.exists()) {
                features = new TreeMap<String, ProvisioningFeatureDefinition>();
                File[] userManifestFiles = userFeatureDir.listFiles(MFFilter);
                if (userManifestFiles != null) {
                    for (File file : userManifestFiles) {
                        try {
                            ProvisioningFeatureDefinition fd = new SubsystemFeatureDefinitionImpl(USR_PRODUCT_EXT_NAME, file);
                            features.put(fd.getSymbolicName(), fd);
                        } catch (IOException e) {
                            // TODO: PROPER NLS MESSAGE
                            throw new FeatureToolException("Unable to read feature manifest from user extension: " + file,
                                                           (String) null,
                                                           e,
                                                           ReturnCode.BAD_FEATURE_DEFINITION);
                        }
                    }
                }
            }
        }

        return features;
    }
1215088
public Map<String, InstalledFeatureCollection> getInstalledFeatureCollections() {
        try {
            Map<String, InstalledFeatureCollection> installedFeatureCollections = new TreeMap<String, InstalledFeatureCollection>();
            Map<String, ProvisioningFeatureDefinition> fdMap = product.getFeatureCollectionDefinitions();
            for (Entry<String, ProvisioningFeatureDefinition> entry : fdMap.entrySet()) {
                installedFeatureCollections.put(entry.getKey(), new InstalledAssetImpl(entry.getValue()));
            }
            return installedFeatureCollections;
        } catch (FeatureToolException rte) {
            log(Level.FINEST, "Director.getInstalledFeatureCollections() got exception.", rte);
            return null;
        }
    }
1011224
public Map<String, Boolean> getApprovalMap() throws ProposalException {

        Lifecycle.QueryApprovalStatusResults rs = getApprovalStatusResults();
        if (rs == null) {
            return Collections.emptyMap();
        }
        return rs.getApprovedMap();
    }
876942
public String get(String extension) {
		Mapping mapping = this.map.get(extension);
		return (mapping != null) ? mapping.getMimeType() : null;
	}
99664
public Map<String, Object> getSiteProperties()
    {
        Map<String, Object> properties = super.getSiteProperties();
        
        String strDomain = this.getProperty(DBParams.DOMAIN);
        if ((strDomain == null) || (strDomain.length() == 0))
            strDomain = DEFAULT_DOMAIN;
        if (strDomain.indexOf('.') != strDomain.lastIndexOf('.'))
            strDomain = strDomain.substring(strDomain.indexOf('.') + 1);
        strDomain = "demo." + strDomain;    // Demo sub-domain
        properties.put(DBParams.DOMAIN, strDomain);
        
        return properties;
    }
889280
public Map<String, ProvisioningFeatureDefinition> getCoreFeatureDefinitionsExceptPlatform() {
        Map<String, ProvisioningFeatureDefinition> features = new TreeMap<String, ProvisioningFeatureDefinition>();
        File featureDir = getCoreFeatureDir();
        //the feature directory may not exist if the packaged server had no features installed when minified
        if (!featureDir.isDirectory() && !featureDir.mkdir()) {
            throw new FeatureToolException("Unable to find or create feature directory: " + featureDir,
                                           MessageFormat.format(NLS.messages.getString("tool.feature.dir.not.found"), featureDir),
                                           null,
                                           ReturnCode.MISSING_CONTENT);
        }

        File[] manifestFiles = featureDir.listFiles(MFFilter);
        if (manifestFiles != null) {
            for (File file : manifestFiles) {
                try {
                    ProvisioningFeatureDefinition fd = new SubsystemFeatureDefinitionImpl(ExtensionConstants.CORE_EXTENSION, file);
                    if (fd.isSupportedFeatureVersion()) {
                        // using symbolic name because gets compared to FeatureResource symbolic name
                        features.put(fd.getSymbolicName(), fd);
                    }
                } catch (IOException e) {
                    // TODO: PROPER NLS MESSAGE
                    throw new FeatureToolException("Unable to read core feature manifest: " + file,
                                                   (String) null,
                                                   e,
                                                   ReturnCode.BAD_FEATURE_DEFINITION);
                }
            }
        }
        return features;
    }
1192634
@Override
    @Trivial
    public Map<String, ExtendedAttributeDefinition> getAttributeMap() {
        Map<String, ExtendedAttributeDefinition> map = null;
        AttributeDefinition[] attrDefs = getAttributeDefinitions(ObjectClassDefinition.ALL);
        if (attrDefs != null) {
            map = new HashMap<String, ExtendedAttributeDefinition>();
            for (AttributeDefinition attrDef : attrDefs) {
                map.put(attrDef.getID(), new ExtendedAttributeDefinitionImpl(attrDef));
            }
        } else {
            map = Collections.emptyMap();
        }
        return map;
    }
233051
public URI getLocation() {
        if (locationURI == null) {
            locationURI = moduleRef != null ? moduleRef.getLocation() : null;
            if (locationURI == null) {
                locationURI = classpathElement.getURI();
            }
        }
        return locationURI;
    }
54771
private function getFindReplaceLocationMapNameText() {
    $config = $this->configFactory->get('openy_programs_search.settings');
    $exclude_location_map = $config->get('name_string_replace_location_map');

    return is_array($exclude_location_map) ? $exclude_location_map : [];
  }
1088716
public function getSitemapLocationsIterableResult() 
	{
		$qb = $this->_em->createQueryBuilder();
		$qb->select(array('a'));
		$qb->from($this->getEntityName(), 'a');		
		//$qb->andWhere($qb->expr()->neq('a.featureCode', ':paramFeatureCode'));
		//$qb->setParameter('paramFeatureCode', Geonames::FEATURE_CODE_ADM3);
		$qb->addOrderBy('a.geonameId', 'ASC');
		
		return $qb->getQuery()->iterate();
	}
524064
public Map<String, Object> getSiteProperties()
    {
        Map<String, Object> properties = super.getSiteProperties();
        
        properties.put(BaseRegistrationScreen.SITE_TEMPLATE_CODE_PARAM, DEFAULT_SITE_TEMPLATE);
        properties.put(BaseRegistrationScreen.SITE_NAME_TEMPLATE_PARAM, "{0} Site");
        properties.put(MenusMessageData.SITE_TEMPLATE_MENU, "site");
        properties.put(MenusMessageData.SITE_HOME_MENU, "siteStart");
        properties.put(TrxMessageHeader.DESTINATION_PARAM, "http://tour-0020.tourgeek.com:8181/xmlws");
        
        return properties;
    }
1210934
public function guessExtension()
    {
        $type = $this->getMimeType();

        return isset(static::$defaultExtensions[$type]) ? static::$defaultExtensions[$type] : null;
    }
30186
protected Map<String, Object> getPluginProperties() {
        Map<String, Object> properties = new HashMap<>();
        if (scanProperties != null) {
            properties.putAll(scanProperties);
        }
        properties.put(ScanInclude.class.getName(), scanIncludes);
        return properties;
    }
386697
public final Map<String, Set<String>> getExtensionMimeMap() throws OSException {
        initializeMimeExtensionArrays();
        return Collections.unmodifiableMap(extensionMime);
    }
77781
@Override
    public Collection<Bundle> getBundles() {
        if (mfDetails == null)
            throw new IllegalStateException("Method called outside of provisioining operation or without a registered service");

        Collection<Bundle> bundles = featureBundles.get();

        if (bundles == null) {
            bundles = new ArrayList<Bundle>();

            Collection<FeatureResource> bundlesInFeature = mfDetails.getConstituents(SubsystemContentType.BUNDLE_TYPE);

            BundleContext ctx = FrameworkUtil.getBundle(FrameworkUtil.class).getBundleContext();

            // symbolic name to bundle map. 
            for (FeatureResource bundle : bundlesInFeature) {
                String location = bundle.getLocation();
                Bundle b = ctx.getBundle(location);
                if (b != null) {
                    bundles.add(b);
                }
            }

            // make an unmodifiable version.
            bundles = Collections.unmodifiableCollection(bundles);

            // store it away if it hasn't already been read. If this is read by another
            // thread at once then this thread will get this collection, and others will
            // the winner's.
            featureBundles.compareAndSet(null, bundles);
        }

        return bundles;
    }
847630
public Map<String, Feature> feature() {
        if (this.feature == null) {
            this.feature = new LinkedHashMap<String, Feature>();
        }
        return this.feature;
    }
799618
public final Map<String, Set<String>> getMimeExtensionMap() throws OSException {
        initializeMimeExtensionArrays();
        return Collections.unmodifiableMap(mimeExtension);
    }