/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.dev.cfg;
import com.google.gwt.core.ext.linker.PropertyProviderGenerator;
import com.google.gwt.dev.util.collect.IdentityHashSet;
import com.google.gwt.dev.util.collect.Lists;
import com.google.gwt.dev.util.collect.Sets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Map.Entry;
import java.util.regex.Pattern;
/**
* Represents a single named deferred binding or configuration property that can
* answer with its value. The BindingProperty maintains two sets of values, the
* "defined" set and the "allowed" set. The allowed set must always be a subset
* of the defined set.
*/
public class BindingProperty extends Property {
public static final String GLOB_STAR = "*";
private static final String EMPTY = "";
private List<SortedSet<String>> collapsedValues = Lists.create();
private final Map<Condition, SortedSet<String>> conditionalValues = new LinkedHashMap<Condition, SortedSet<String>>();
private final SortedSet<String> definedValues = new TreeSet<String>();
private PropertyProvider provider;
private Class<? extends PropertyProviderGenerator> providerGenerator;
private String fallback;
private HashMap<String,LinkedList<LinkedHashSet<String>>> fallbackValueMap;
private HashMap<String,LinkedList<String>> fallbackValues = new HashMap<String,LinkedList<String>>();
private final ConditionAll rootCondition = new ConditionAll();
{
conditionalValues.put(rootCondition, new TreeSet<String>());
}
public BindingProperty(String name) {
super(name);
fallback = EMPTY;
}
/**
* Add an equivalence set of property values.
*/
public void addCollapsedValues(String... values) {
// Sanity check caller
for (String value : values) {
if (value.contains(GLOB_STAR)) {
// Expanded in normalizeCollapsedValues()
continue;
} else if (!definedValues.contains(value)) {
throw new IllegalArgumentException(
"Attempting to collapse unknown value " + value);
}
}
// We want a mutable set, because it simplifies normalizeCollapsedValues
SortedSet<String> temp = new TreeSet<String>(Arrays.asList(values));
collapsedValues = Lists.add(collapsedValues, temp);
}
public void addDefinedValue(Condition condition, String newValue) {
definedValues.add(newValue);
SortedSet<String> set = conditionalValues.get(condition);
if (set == null) {
set = new TreeSet<String>();
set.addAll(conditionalValues.get(rootCondition));
conditionalValues.put(condition, set);
}
set.add(newValue);
}
/**
* Adds fall back value to given property name.
* @param value the property value.
* @param fallbackValue the fall back value for given property value.
*/
public void addFallbackValue(String value, String fallbackValue) {
LinkedList<String> values = fallbackValues.get(fallbackValue);
if (values == null) {
values = new LinkedList<String>();
fallbackValues.put(fallbackValue, values);
}
values.addFirst(value);
}
/**
* Returns the set of allowed values in sorted order when a certain condition
* is satisfied.
*/
public String[] getAllowedValues(Condition condition) {
Set<String> allowedValues = conditionalValues.get(condition);
return allowedValues.toArray(new String[allowedValues.size()]);
}
public List<SortedSet<String>> getCollapsedValues() {
return collapsedValues;
}
public Map<Condition, SortedSet<String>> getConditionalValues() {
return Collections.unmodifiableMap(conditionalValues);
}
/**
* If the BindingProperty has exactly one value across all conditions and
* permutations, return that value otherwise return <code>null</code>.
*/
public String getConstrainedValue() {
String constrainedValue = null;
for (SortedSet<String> allowedValues : conditionalValues.values()) {
if (allowedValues.size() != 1) {
return null;
} else if (constrainedValue == null) {
constrainedValue = allowedValues.iterator().next();
} else if (!constrainedValue.equals(allowedValues.iterator().next())) {
return null;
}
}
return constrainedValue;
}
/**
* Returns the set of defined values in sorted order.
*/
public String[] getDefinedValues() {
return definedValues.toArray(new String[definedValues.size()]);
}
/**
* Returns the fallback value for this property, or the empty string if none.
*
* @return the fallback value
*/
public String getFallback() {
return fallback;
}
/**
* Returns the map of values to fall back values. the list of fall
* back values is in decreasing order of preference.
* @return map of property value to fall back values.
*/
public Map<String,? extends List<? extends Set<String>>> getFallbackValuesMap() {
if (fallbackValueMap == null) {
HashMap<String,LinkedList<LinkedHashSet<String>>> valuesMap = new HashMap<String,LinkedList<LinkedHashSet<String>>>();
// compute closure of fall back values preserving order
for (Entry<String, LinkedList<String>> e : fallbackValues.entrySet()) {
String from = e.getKey();
LinkedList<LinkedHashSet<String>> alternates = new LinkedList<LinkedHashSet<String>>();
valuesMap.put(from, alternates);
LinkedList<String> childList = fallbackValues.get(from);
LinkedHashSet<String> children = new LinkedHashSet<String>();
children.addAll(childList);
while (children != null && children.size() > 0)
{
alternates.add(children);
LinkedHashSet<String> newChildren = new LinkedHashSet<String>();
for (String child : children) {
childList = fallbackValues.get(child);
if (null == childList) {
continue;
}
for (String val : childList) {
newChildren.add(val);
}
}
children = newChildren;
}
}
fallbackValueMap = valuesMap;
}
return fallbackValueMap;
}
public PropertyProvider getProvider() {
return provider;
}
/**
* @return the the provider generator class, or null if none.
*/
public Class<? extends PropertyProviderGenerator> getProviderGenerator() {
return providerGenerator;
}
public Set<String> getRequiredProperties() {
Set<String> toReturn = Sets.create();
for (Condition cond : conditionalValues.keySet()) {
toReturn = Sets.addAll(toReturn, cond.getRequiredProperties());
}
return toReturn;
}
public ConditionAll getRootCondition() {
return rootCondition;
}
/**
* Returns true if the supplied value is legal under some condition.
*/
public boolean isAllowedValue(String value) {
for (Set<String> values : conditionalValues.values()) {
if (values.contains(value)) {
return true;
}
}
return false;
}
/**
* Returns <code>true</code> if the value was previously provided to
* {@link #addDefinedValue(Condition,String)}.
*/
public boolean isDefinedValue(String value) {
return definedValues.contains(value);
}
/**
* Returns <code>true</code> if the value of this BindingProperty is always
* derived from other BindingProperties. That is, for each Condition in the
* BindingProperty, there is exactly one allowed value.
*/
public boolean isDerived() {
for (Set<String> allowedValues : conditionalValues.values()) {
if (allowedValues.size() != 1) {
return false;
}
}
return true;
}
/**
* Set the currently allowed values. The values provided must be a subset of
* the currently-defined values.
*
* @throws IllegalArgumentException if any of the provided values were not
* provided to {@link #addDefinedValue(Condition,String)}.
*/
public void setAllowedValues(Condition condition, String... values) {
SortedSet<String> temp = new TreeSet<String>(Arrays.asList(values));
if (!definedValues.containsAll(temp)) {
throw new IllegalArgumentException(
"Attempted to set an allowed value that was not previously defined");
}
// XML has a last-one-wins semantic which we reflect in our evaluation order
if (condition == rootCondition) {
/*
* An unconditional set-property would undo any previous conditional
* setters, so we can just clear out this map.
*/
conditionalValues.clear();
} else {
/*
* Otherwise, we'll just ensure that this condition is moved to the end.
*/
conditionalValues.remove(condition);
}
conditionalValues.put(condition, temp);
}
public void setFallback(String token) {
fallback = token;
}
public void setProvider(PropertyProvider provider) {
this.provider = provider;
}
/**
* Set a provider generator for this property.
*
* @param generator
*/
public void setProviderGenerator(Class<? extends PropertyProviderGenerator> generator) {
providerGenerator = generator;
}
/**
* Create a minimal number of equivalence sets, expanding any glob patterns.
*/
void normalizeCollapsedValues() {
if (collapsedValues.isEmpty()) {
return;
}
// Expand globs
for (Set<String> set : collapsedValues) {
// Compile a regex that matches all glob expressions that we see
StringBuilder pattern = new StringBuilder();
for (Iterator<String> it = set.iterator(); it.hasNext();) {
String value = it.next();
if (value.contains(GLOB_STAR)) {
it.remove();
if (pattern.length() > 0) {
pattern.append("|");
}
// a*b ==> (a.*b)
pattern.append("(");
// We know value is a Java ident, so no special escaping is needed
pattern.append(value.replace(GLOB_STAR, ".*"));
pattern.append(")");
}
}
if (pattern.length() == 0) {
continue;
}
Pattern p = Pattern.compile(pattern.toString());
for (String definedValue : definedValues) {
if (p.matcher(definedValue).matches()) {
set.add(definedValue);
}
}
}
// Minimize number of sets
// Maps a value to the set that contains that value
Map<String, SortedSet<String>> map = new HashMap<String, SortedSet<String>>();
// For each equivalence set we have
for (SortedSet<String> set : collapsedValues) {
// Examine each original value in the set
for (String value : new LinkedHashSet<String>(set)) {
// See if the value was previously assigned to another set
SortedSet<String> existing = map.get(value);
if (existing == null) {
map.put(value, set);
} else {
// If so, merge the existing set into this one and update pointers
set.addAll(existing);
for (String mergedValue : existing) {
map.put(mergedValue, set);
}
}
}
}
// The values of the maps will now contain the minimal number of sets
collapsedValues = new ArrayList<SortedSet<String>>(
new IdentityHashSet<SortedSet<String>>(map.values()));
// Sort the list
Lists.sort(collapsedValues, new Comparator<SortedSet<String>>() {
public int compare(SortedSet<String> o1, SortedSet<String> o2) {
String s1 = o1.toString();
String s2 = o2.toString();
assert !s1.equals(s2) : "Should not have seen equal sets";
return s1.compareTo(s2);
}
});
}
}