Converts a property map propertyKey -> propertyValue to a list of OpenConnection.Properties
@param properties The map to convert
@return A list of Properties
341120
private List<OpenConnection.Property> convertToPropertyList(Map<String, String> properties) {
        return properties.entrySet()
                .stream()
                .map(this::convertToProperty)
                .sorted(Comparator.comparingInt(OpenConnection.Property::hashCode))
                .collect(Collectors.toList());
    }
76204
public ConnectionInput withConnectionProperties(java.util.Map<String, String> connectionProperties) {
        setConnectionProperties(connectionProperties);
        return this;
    }
1254119
public static Config parse(Properties properties) {
        ConfigBuilder config = new SimpleConfig();
        for (Object o : new TreeSet<>(properties.keySet())) {
            String key = o.toString();
            if (isPositional(key)) {
                String entryKey = entryKey(key);
                if (config.containsKey(entryKey)) {
                    config.getCollection(entryKey).add(properties.getProperty(key));
                } else {
                    ArrayList<Object> sequence = new ArrayList<>();
                    sequence.add(properties.getProperty(key));
                    config.putCollection(entryKey, sequence);
                }
            } else {
                config.put(key, properties.getProperty(key));
            }
        }
        return ImmutableConfig.copyOf(config);
    }
412025
public static Properties jslPropertiesToJavaProperties(
            final JSLProperties xmlProperties) {

        final Properties props = new Properties();

        for (final Property prop : xmlProperties.getPropertyList()) {
            props.setProperty(prop.getName(), prop.getValue());
        }

        return props;

    }
901141
public List<String> getDispatcherKeysForProperty(String propertyKey, @Nullable String propertyValue) {
    ImmutableList.Builder<String> keys = ImmutableList.builder();
    for (NotificationDispatcherMetadata metadata : dispatchersMetadata) {
      String dispatcherKey = metadata.getDispatcherKey();
      String value = metadata.getProperty(propertyKey);
      if (value != null && (propertyValue == null || value.equals(propertyValue))) {
        keys.add(dispatcherKey);
      }
    }
    return keys.build();
  }
1071802
public Configuration withProperties(java.util.Map<String, String> properties) {
        setProperties(properties);
        return this;
    }
198207
public Map getConnectionProperties()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "getConnectionProperties");
            SibTr.exit(tc, "getConnectionProperties", _connectionProperties);
        }
        return _connectionProperties;
    }
611610
public ArrayList getProperties(){
		ArrayList properties = new ArrayList();
		if (configEntry.properties != null){
			Iterator it = configEntry.properties.values().iterator();
			while (it.hasNext()){
				Property property = new Property((com.ibm.ws.cache.config.Property)it.next());
				properties.add(property);
			}
		}
		return properties;
	}
678185
@Override
    public void populateClientProperties(Client client, Map<String, Object> properties)
    {
        this.clientProperties = properties;
    }
612173
public static String[] propertiesToArgs(Map<String,Object> properties)
    {
        if (properties == null)
            return null;
        String[] rgArgs = new String[properties.size()];
        int i = 0;
        for (String strKey : properties.keySet())
        {
            Object strValue = properties.get(strKey);
            rgArgs[i++] = strKey.toString() + '=' + strValue.toString();
        }
        return rgArgs;
    }
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;
    }
1194882
public Map<String, Object> convertPropertiesToMap(Properties properties) {
        return properties.entrySet().stream()
                .collect(toLinkedMap(
                        e -> e.getKey().toString(),
                        e -> e.getValue()));
    }
793074
@Override
	public Set<PropertyKey> getPropertyKeys(final String propertyView) {
		return StructrApp.getConfiguration().getPropertySet(this.getClass(), propertyView);
	}
904175
public static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz) {
        PropertyDescriptor[] properties = propertyDescriptors(clazz);
        Map<String, PropertyDescriptor> mappedProperties = new HashMap<String, PropertyDescriptor>();

        for (PropertyDescriptor property : properties) {
            if ("class".equals(property.getName()) == false) {
                mappedProperties.put(property.getName(), property);
            }
        }

        return mappedProperties;
    }
331365
public Set<String> getValues(String property) {
		Set<String> allValues = new HashSet<>();
		for (PropertiesCoreExtension<T, ?, ?, ?> properties : propertiesMap
				.values()) {
			allValues.addAll(properties.getValues(property));
		}
		return allValues;
	}
1245060
public static String join(List<? extends PropertyInfo> properties) {
    StringBuilder sb = new StringBuilder();
    for (PropertyInfo info : properties)
      sb.append(info.getName()).append('.');
    return sb.toString();
  }
126928
public final <C extends Property> PropertyList<C> getProperties(final String name) {
        return getProperties().getProperties(name);
    }