Returns a configuration property <b>List</b> value based off the {@link ConfigProperty}

@param configProperty
String Property Name
@return The configuration property <b>List</b> value or an empty <b>List</b>.
433598
public static List<Object> getListConfigProperty(String configProperty) {
        checkArgument(configProperty != null, "Config property cannot be null");
        return getConfig().getList(configProperty);
    }
1258192
static String[] getProp(final Map<String, String[]> prop, final String propertyName) {
        String[] result = null;
        if (prop != null) {
            for (final Entry<String, String[]> entry : prop.entrySet()) {
                if (entry.getKey().equalsIgnoreCase(propertyName)) {
                    result = entry.getValue();
                }
            }
        }
        return result;
    }
1314676
public Class<?> getClass(String property) {
    return getProperty(property, className -> {
      try {
        return Class.forName(className);
      } catch (ClassNotFoundException e) {
        throw new ConfigurationException("unknown class: " + className, e);
      }
    });
  }
309839
public Map<String,Object> addConfigProperty(Map<String,Object> properties, String key, String defaultValue)
    {
    	if (this.getProperty(key) != null)
    		properties.put(key, this.getProperty(key));
    	else if (defaultValue != null)
    		properties.put(key, defaultValue);
    	return properties;
    }
203504
public static String getProperty(String base, String property) {
		return getProperty(base, property, true);
	}
1106501
public String getProperty(String key, String defaultValue) {
        return mProperties.getProperty(key, defaultValue);
    }
1071802
public Configuration withProperties(java.util.Map<String, String> properties) {
        setProperties(properties);
        return this;
    }
618120
public static Map<String, CmsProperty> getPropertyMap(List<CmsProperty> list) {

        Map<String, CmsProperty> result = null;
        String key = null;
        CmsProperty property = null;

        if ((list == null) || (list.size() == 0)) {
            return Collections.emptyMap();
        }

        result = new HashMap<String, CmsProperty>();

        // choose the fastest method to iterate the list
        if (list instanceof RandomAccess) {
            for (int i = 0, n = list.size(); i < n; i++) {
                property = list.get(i);
                key = property.getName();
                result.put(key, property);
            }
        } else {
            Iterator<CmsProperty> i = list.iterator();
            while (i.hasNext()) {
                property = i.next();
                key = property.getName();
                result.put(key, property);
            }
        }

        return result;
    }
1033368
private Map<String, Object> getProperties(GDLParser.PropertiesContext propertiesContext) {
    if (propertiesContext != null) {
      Map<String, Object> properties = new HashMap<>();
      for (GDLParser.PropertyContext property : propertiesContext.property()) {
        properties.put(property.Identifier().getText(), getPropertyValue(property.literal()));
      }
      return properties;
    }
    return Collections.emptyMap();
  }
447342
public long getLong(String property) {
    return getProperty(property, value -> {
      try {
        return Long.valueOf(value);
      } catch (NumberFormatException e) {
        throw new ConfigurationException("malformed property value: " + property + " must be a long");
      }
    });
  }
112683
public static ConfigID fromProperty(String property) {
        //TODO Perhaps there is a clever regex that could handle this
        String[] parents = property.split("//");

        ConfigID id = null;
        for (String parentString : parents) {
            id = constructId(id, parentString);
        }

        return id;
    }
32150
@Nonnull
	public static Configuration createConfiguration(Properties properties) {
		final Configuration configuration = new Configuration();

		final Set<String> propertyNames = properties.stringPropertyNames();

		for (String propertyName : propertyNames) {
			configuration.setString(propertyName, properties.getProperty(propertyName));
		}

		return configuration;
	}
1347495
public static ValueType fromConfig(String property) {
      //If the property is valid and we cannot find a "property.type" then the value of the property represents its simple type.
      if (Config.hasProperty(property) && !Config.hasProperty(property, TYPE_PROPERTY)) {
         return new SimpleValueType(Config.get(property).asClass());
      }

      if( Config.isBean(property) ){
         Object o = Config.get(property);
         return new SimpleValueType(o.getClass());
      }

      //Read in the value type parameters from the configuration using the property as the prefix
      Map<String, Class> typeInfo = Config.getMap(property, String.class, Class.class);
      //Set the type class to the type property defaulting to String if not found
      Class<?> typeClass = typeInfo.getOrDefault(TYPE_PROPERTY, String.class);


      //Check for a collection
      if (Collection.class.isAssignableFrom(typeClass)) {
         return new CollectionValueType(typeClass,
                                        typeInfo.getOrDefault(ELEMENT_TYPE_PROPERTY, String.class)
         );
      }

      //Check for a Map
      if (Map.class.isAssignableFrom(typeClass)) {
         return new MapValueType(typeClass,
                                 typeInfo.getOrDefault(KEY_TYPE_PROPERTY, String.class),
                                 typeInfo.getOrDefault(VALUE_TYPE_PROPERTY, String.class)
         );
      }

      return new SimpleValueType(typeClass);
   }
1031582
@Override
  public final String reconfigureProperty(String property, String newVal)
    throws ReconfigurationException {
    if (isPropertyReconfigurable(property)) {
      String oldVal;
      synchronized(getConf()) {
        oldVal = getConf().get(property);
        reconfigurePropertyImpl(property, newVal);
        if (newVal != null) {
          getConf().set(property, newVal);
        } else {
          getConf().unset(property);
        }
      }
      return oldVal;
    } else {
      throw new ReconfigurationException(property, newVal,
                                             getConf().get(property));
    }
  }
558518
private String getProperty(String property) {

        String ret = sdkProperties.getProperty(property);

        if (null == ret) {
            logger.warn(String.format("No configuration value found for '%s'", property));
        }
        return ret;
    }
1279321
public Collection<String> getValues(String property) {
        Multimap<Optional<String>, String> values = properties.get(property);
        if (values == null) {
            return Collections.emptyList();
        }

        return values.values();
    }
1103207
public String getProperty(String strProperty)
    {
        String strValue = super.getProperty(strProperty);
        if (strValue == null)
        {
            App appDefault = this.getEnvironment().getDefaultApplication();
            if ((appDefault != null)
                && (appDefault != this))
                    strValue = appDefault.getProperty(strProperty);
        }
        return strValue;
    }