Creates a lazy property map which creates properties on lookup if they don'T exist.<p>

@param properties the properties which should be initially put into the map

@return the lazy property map
160765
public static Map<String, CmsClientProperty> toLazyMap(Map<String, CmsClientProperty> properties) {

        Map<String, CmsClientProperty> result = new CmsLazyPropertyMap(properties);
        return result;
    }
50061
public VarValueDef addProperties( Collection<String> properties)
    {
    if( properties != null)
      {
      assertPropertyIdentifiers( properties);
      properties_.addAll( properties);
      }

    return this;
    }
995314
public static Map<String, CmsXmlContentProperty> resolveMacrosInProperties(
        Map<String, CmsXmlContentProperty> properties,
        I_CmsMacroResolver resolver) {

        Map<String, CmsXmlContentProperty> result = new LinkedHashMap<String, CmsXmlContentProperty>();
        for (Map.Entry<String, CmsXmlContentProperty> entry : properties.entrySet()) {
            String key = entry.getKey();
            CmsXmlContentProperty prop = entry.getValue();
            result.put(key, resolveMacrosInProperty(prop, resolver));
        }
        return result;
    }
1133726
protected Map<String, CmsProperty> getActiveProperties() {

        // get all used properties for the resource
        if (m_activeProperties == null) {
            try {
                m_activeProperties = CmsPropertyAdvanced.getPropertyMap(
                    getCms().readPropertyObjects(getParamResource(), false));
            } catch (CmsException e) {
                // create an empty list
                if (LOG.isInfoEnabled()) {
                    LOG.info(e.getLocalizedMessage());
                }
                m_activeProperties = new HashMap<String, CmsProperty>();
            }
        }
        return m_activeProperties;
    }
805278
public void setMapperProperties(Properties properties) {
        if (this.mapperHelper == null) {
            this.mapperHelper = new MapperHelper();
        }
        this.mapperHelper.setProperties(properties);
    }
1129667
private Set<VarBindingDef> getPropertyProviders( Set<String> properties)
    {
    Set<VarBindingDef> bindings = new HashSet<VarBindingDef>();
    for( String property : properties)
      {
      bindings.addAll( propertyProviders_.get( property));
      }

    return bindings;
    }
1071802
public Configuration withProperties(java.util.Map<String, String> properties) {
        setProperties(properties);
        return this;
    }
323796
@Override
	public synchronized void setProperties(Map<Object, Object> properties)
	{
		if(this.properties == null)
			this.properties = new Properties();
		
		
		this.properties.putAll(properties);
	}
753748
public Map<String, Object> getProperties() {
        // Shallow copy entries to a newly instantiated HashMap.
        Map<String, Object> clone = new HashMap<String, Object>();
        Set<Entry<String, Object>> set = _properties.entrySet();
        
        for (Entry<String, Object> entry : set) {
            // There wouldn't be any entry with a null value.
            clone.put(entry.getKey(), entry.getValue());
        }
        
        return clone;
    }
380617
public SimpleHTMLTag setProperties(Map<String, String> properties) {
        if (properties == null || properties.isEmpty()) {
            this.properties = null;
        } else {
            this.properties = new HashMap<>();

            for (Entry<String, String> entry : properties.entrySet()) {
                String key = entry.getKey();
                key = UniformUtils.checkPropertyNameAndLowerCase(key);

                this.properties.put(key, entry.getValue());
            }
        }

        return this;
    }
934291
@NonNull
    public static PropertyExpression property(@NonNull String property) {
        if (property == null) {
            throw new IllegalArgumentException("property cannot be null.");
        }
        return new PropertyExpression(property);
    }
1167169
public Collection<String> getNames(Collection<P> properties)
  {
    Preconditions.checkNotNull(properties);
    return Collections2.transform(properties, new Function<P, String>()
    {
      @Override
      public String apply(P property)
      {
        return converter.convert(property);
      }
    });
  }
914295
public PropertySet removeAll( Collection<String> properties)
    {
    if( properties != null)
      {
      removeAll( properties.iterator());
      }
    
    return this;
    }
544737
public void setProperties(Map<String, Object> properties)
    {
        if (this.getParentRecordOwner() != null)
            this.getParentRecordOwner().setProperties(properties);
    }
253150
public static HashSet<String> createSetFromProperty(String property)
	{
		HashSet<String> properties = new HashSet<String>();

		if (property != null && !property.equals("null")) {
			// "([\\w]*)=([\\w]*);"
			Pattern params = Pattern.compile("([\\w]+)[;]*");
			Matcher matcher = params.matcher(property.trim());
			while (matcher.find()) {
				properties.add(matcher.group(1));
			}

		}

		return properties;
	}
135671
public Map<String, Map<String, String>> getPropertyLocaleSearch() {

        if (m_propertiesLocaleSearch == null) {
            m_propertiesLocaleSearch = CmsCollectionsGenericWrapper.createLazyMap(
                new CmsLocalePropertyLoaderTransformer(getCmsObject(), this, true));
            // result may still be null
            return (m_propertiesLocaleSearch == null) ? Collections.EMPTY_MAP : m_propertiesLocaleSearch;
        }
        return m_propertiesLocaleSearch;
    }
905462
public final MapDictionary<String, Object> getProperties() {
        if (this.properties.isReadyOnly()) {
            return this.properties;
        }
        return new MapDictionary<String, Object>(this.properties);
    }