Returns a new map with the calculated properties removed. If null, null
is returned.

@param contentProperties
@return
498853
public static Map<String, String> removeCalculatedProperties(Map<String, String> contentProperties) {
        if (contentProperties != null) {
            contentProperties = new HashMap<>(contentProperties);
            // Remove calculated properties
            contentProperties.remove(StorageProvider.PROPERTIES_CONTENT_MD5);
            contentProperties.remove(StorageProvider.PROPERTIES_CONTENT_CHECKSUM);
            contentProperties.remove(StorageProvider.PROPERTIES_CONTENT_MODIFIED);
            contentProperties.remove(StorageProvider.PROPERTIES_CONTENT_SIZE);
        }
        return contentProperties;

    }
236112
public static Map<String, Object> configureObjectFieldsWithProperties(
            final Object object,
            final List<Property> properties,
            final Map<String, Object> inputConfig
    )
    {
        HashMap<String, Object> modified = new HashMap<>(inputConfig);
        for (final Property property : properties) {
            if (null != modified.get(property.getName())) {
                if (setValueForProperty(property, modified.get(property.getName()), object)) {
                    modified.remove(property.getName());
                }
            }
        }
        return modified;
    }
405242
public EntityBuilder addProperties(Map<String, Object> properties) {
    	if(MapUtils.isEmpty(properties)) {
    		throw new IllegalArgumentException("properties cannot be null or empty.");
    	}
        for (String key : properties.keySet()) {
            addProperty(key, properties.get(key));
        }
        return this;
    }
1238830
@InterfaceAudience.Public
    public Map<String, Object> getDocumentProperties() {
        return documentRevision != null ? documentRevision.getProperties() : null;
    }
426130
private Properties mapToProperties(Map<String, String> map) {
		   Properties p = new Properties();
		   for (Map.Entry<String,String> entry : map.entrySet()) {
		     p.put(entry.getKey(), entry.getValue());
		   }
		   return p;
		 }
1116374
public static Map<String, CmsClientProperty> makeLazyCopy(Map<String, CmsClientProperty> properties) {

        if (properties == null) {
            return null;
        }
        return toLazyMap(copyProperties(properties));
    }
718510
public MAP inboundMap(Map<String, Object> ctx)
   {
      AddressingProperties implementation = (AddressingProperties)ctx.get(CXFMAPConstants.SERVER_ADDRESSING_PROPERTIES_INBOUND);
      return newMap(implementation);
   }
1112431
public static @Extension ContentMappings newInstance() throws IOException {
        ContentMappings mappings = Persistence.load(ContentMappings.class);
        if (mappings == null) {
            mappings = (ContentMappings) new XmlProxy().readResolve();
        }
        return mappings;
    }
876030
public Map<String, String> getPropertiesAsMap(Properties properties) {
		Map<String, String> result = new HashMap<String, String>();
		for (String key : properties.stringPropertyNames()) {
			result.put(key, properties.getProperty(key));
		}
		return result;
	}
286125
protected List<CmsProperty> readPropertiesFromManifest(Element parentElement, List<String> ignoredPropertyKeys) {

        // all imported Cms property objects are collected in map first forfaster access
        Map<String, CmsProperty> properties = new HashMap<String, CmsProperty>();
        CmsProperty property = null;
        List<Node> propertyElements = parentElement.selectNodes(
            "./" + A_CmsImport.N_PROPERTIES + "/" + A_CmsImport.N_PROPERTY);
        Element propertyElement = null;
        String key = null, value = null;
        Attribute attrib = null;

        // iterate over all property elements
        for (int i = 0, n = propertyElements.size(); i < n; i++) {
            propertyElement = (Element)propertyElements.get(i);
            key = getChildElementTextValue(propertyElement, A_CmsImport.N_NAME);

            if ((key == null) || ignoredPropertyKeys.contains(key)) {
                // continue if the current property (key) should be ignored or is null
                continue;
            }

            // all Cms properties are collected in a map keyed by their property keys
            property = properties.get(key);
            if (property == null) {
                property = new CmsProperty();
                property.setName(key);
                property.setAutoCreatePropertyDefinition(true);
                properties.put(key, property);
            }

            value = getChildElementTextValue(propertyElement, A_CmsImport.N_VALUE);
            if (value == null) {
                value = "";
            }

            attrib = propertyElement.attribute(A_CmsImport.N_PROPERTY_ATTRIB_TYPE);
            if ((attrib != null) && attrib.getValue().equals(A_CmsImport.N_PROPERTY_ATTRIB_TYPE_SHARED)) {
                // it is a shared/resource property value
                property.setResourceValue(value);
            } else {
                // it is an individual/structure value
                property.setStructureValue(value);
            }
        }

        return new ArrayList<CmsProperty>(properties.values());
    }
181874
@Override
    public Map<String, String> getContentProperties(String spaceID,
                                                    String contentID,
                                                    String storeID)
        throws ResourceException {
        try {
            StorageProvider storage =
                storageProviderFactory.getStorageProvider(storeID);
            return storage.getContentProperties(spaceID, contentID);
        } catch (NotFoundException e) {
            throw new ResourceNotFoundException("get properties for content",
                                                spaceID,
                                                contentID,
                                                e);
        } catch (Exception e) {
            storageProviderFactory.expireStorageProvider(storeID);
            throw new ResourceException("get properties for content",
                                        spaceID,
                                        contentID,
                                        e);
        }
    }
36528
@java.lang.Deprecated
  public java.util.Map<java.lang.String, com.google.datastore.v1.Value> getProperties() {
    return getPropertiesMap();
  }
769496
function (content, properties) {
    var lines = content.split(lineEndingRE);
    lines = replaceProperties(lines, properties);
    lines = replaceSymbols(lines);
    return lines.join('\n');
  }
650560
public Map<String, String> encode(Map<String, Object> tableProperties)
    {
        return ImmutableMap.of();
    }
1003640
public static CmsFlexBucketConfiguration loadFromProperties(Properties properties) {

        ArrayListMultimap<String, String> multimap = ArrayListMultimap.create();
        List<String> clearAll = Lists.newArrayList();
        for (Object keyObj : properties.keySet()) {
            String key = (String)keyObj;
            key = key.trim();
            String value = (String)(properties.get(key));
            value = value.trim();
            if (key.startsWith(KEY_PREFIX_BUCKET)) {
                String bucketName = key.substring(KEY_PREFIX_BUCKET.length());
                multimap.putAll(bucketName, Arrays.asList(value.trim().split(" *, *")));
            } else if (KEY_CLEAR_ALL.equals(key)) {
                clearAll = Arrays.asList(value.trim().split(" *, *"));
            }
        }
        CmsFlexBucketConfiguration result = new CmsFlexBucketConfiguration();
        if (!clearAll.isEmpty()) {
            result.setClearAll(clearAll);
        }
        for (String key : multimap.keySet()) {
            result.add(key, multimap.get(key));
        }
        result.freeze();
        return result;
    }
922031
private <T extends Property> Map<String, String> getOverriddenImplementationConfiguration(
            Collection<T> overridableProperties) {

        Map<String, String> ret = new HashMap<>();

        overridableProperties.forEach(p -> {
            String val = getProperty(p, null);
            if (val != null) {
                ret.put(p.getPropertyName(), val);
            }
        });

        implementationConfiguration.forEach(ret::putIfAbsent);

        return ret;
    }
941618
protected Map<String, CmsClientProperty> convertProperties(List<CmsProperty> properties) {

        Map<String, CmsClientProperty> result = new HashMap<String, CmsClientProperty>();
        for (CmsProperty prop : properties) {
            CmsClientProperty clientProp = new CmsClientProperty(
                prop.getName(),
                prop.getStructureValue(),
                prop.getResourceValue());
            clientProp.setOrigin(prop.getOrigin());
            result.put(clientProp.getName(), clientProp);
        }
        return result;
    }