Java tutorial
/* * Copyright 2013 NGDATA nv * Copyright 2008 Outerthought bvba and Schaubroeck nv * * 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 org.lilyproject.runtime.conf; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.jxpath.JXPathContext; import org.lilyproject.runtime.conf.jxpath.ConfPointerFactory; import org.lilyproject.util.location.Location; import org.lilyproject.util.location.LocationImpl; public class ConfImpl implements Conf { private List<ConfImpl> children = new ArrayList<ConfImpl>(); private Map<String, String> attributes = new HashMap<String, String>(); private String name; private String value; private Location location; private Inheritance inheritance; /** * Inheritance uniqueness constraint: an expression (JXPath) used when inheriting to determine * if a node is already present. * */ private String inheritConstraint; public enum Inheritance { NONE, SHALLOW, DEEP } static { ConfPointerFactory.register(); } public ConfImpl(String name, Location location) { if (name == null) { throw new IllegalArgumentException("Null argument: name"); } if (location == null) { throw new IllegalArgumentException("Null argument: location"); } this.name = name; this.location = location; } public void addChild(ConfImpl config) { if (config == null) { throw new IllegalArgumentException("Null argument: config"); } this.children.add(config); } public void setValue(String value) { if (value == null) { throw new IllegalArgumentException("Null argument: config"); } if (value.length() != value.trim().length()) { throw new IllegalArgumentException("Configuration values should be trimmed."); } if (value.length() == 0) { throw new IllegalArgumentException("Configuration values should have a length > 0."); } this.value = value; } public void addAttribute(String name, String value) { attributes.put(name, value); } public List<Conf> getChildren() { return Collections.<Conf>unmodifiableList(children); } public boolean hasChildren() { return children.size() > 0; } public List<Conf> getChildren(String name) { List<Conf> result = new ArrayList<Conf>(); for (Conf conf : children) { if (conf.getName().equals(name)) { result.add(conf); } } return Collections.unmodifiableList(result); } public Conf getChild(String name) { return getChild(name, true); } public Conf getChild(String name, boolean create) { for (Conf conf : children) { if (conf.getName().equals(name)) { return conf; } } if (create) { return new ConfImpl(name, new LocationImpl(null, "<generated>" + location.getURI(), location.getLineNumber(), location.getColumnNumber())); } else { return null; } } public Conf getRequiredChild(String name) { Conf child = getChild(name, false); if (child != null) { return child; } else { throw new ConfException( "Missing configuration node \"" + name + "\" inside " + name + " at " + getLocation()); } } public String getName() { return name; } public Location getLocation() { return location; } public String getValue() { checkValuePresent(); return value; } public boolean getValueAsBoolean() { return convertToBoolean(getValue(), null); } public int getValueAsInteger() { return convertToInteger(getValue(), null); } public long getValueAsLong() { return convertToLong(getValue(), null); } public float getValueAsFloat() { return convertToFloat(getValue(), null); } public double getValueAsDouble() { return convertToDouble(getValue(), null); } public String getValue(String defaultValue) { if (value == null) { return defaultValue; } return getValue(); } public Boolean getValueAsBoolean(Boolean defaultValue) { if (value == null) { return defaultValue; } return getValueAsBoolean(); } public Integer getValueAsInteger(Integer defaultValue) { if (value == null) { return defaultValue; } return getValueAsInteger(); } public Long getValueAsLong(Long defaultValue) { if (value == null) { return defaultValue; } return getValueAsLong(); } public Float getValueAsFloat(Float defaultValue) { if (value == null) { return defaultValue; } return getValueAsFloat(); } public Double getValueAsDouble(Double defaultValue) { if (value == null) { return defaultValue; } return getValueAsDouble(); } public Map<String, String> getAttributes() { return Collections.unmodifiableMap(attributes); } public String getAttribute(String name) { checkAttributePresent(name); return attributes.get(name); } public boolean getAttributeAsBoolean(String name) { return convertToBoolean(getAttribute(name), name); } public int getAttributeAsInteger(String name) { return convertToInteger(getAttribute(name), name); } public long getAttributeAsLong(String name) { return convertToLong(getAttribute(name), name); } public float getAttributeAsFloat(String name) { return convertToFloat(getAttribute(name), name); } public double getAttributeAsDouble(String name) { return convertToDouble(getAttribute(name), name); } public String getAttribute(String name, String defaultValue) { if (!attributes.containsKey(name)) { return defaultValue; } return getAttribute(name); } public Boolean getAttributeAsBoolean(String name, Boolean defaultValue) { if (!attributes.containsKey(name)) { return defaultValue; } return getAttributeAsBoolean(name); } public Integer getAttributeAsInteger(String name, Integer defaultValue) { if (!attributes.containsKey(name)) { return defaultValue; } return getAttributeAsInteger(name); } public Long getAttributeAsLong(String name, Long defaultValue) { if (!attributes.containsKey(name)) { return defaultValue; } return getAttributeAsLong(name); } public Float getAttributeAsFloat(String name, Float defaultValue) { if (!attributes.containsKey(name)) { return defaultValue; } return getAttributeAsFloat(name); } public Double getAttributeAsDouble(String name, Double defaultValue) { if (!attributes.containsKey(name)) { return defaultValue; } return getAttributeAsDouble(name); } private void checkValuePresent() { if (value == null) { throw new ConfException( "No value is associated with the configuration element " + getName() + " at " + getLocation()); } } private void checkAttributePresent(String attributeName) { if (!attributes.containsKey(attributeName)) { throw new ConfException("No attribute \"" + attributeName + "\" on the configuration element " + getName() + " at " + getLocation()); } } private boolean convertToBoolean(String value, String attributeName) { if (value.equalsIgnoreCase("true") || value.equalsIgnoreCase("t") || value.equalsIgnoreCase("yes") || value.equalsIgnoreCase("y")) { return true; } else if (value.equalsIgnoreCase("false") || value.equalsIgnoreCase("f") || value.equalsIgnoreCase("no") || value.equalsIgnoreCase("n")) { return false; } else { produceBadFormatException("boolean", value, attributeName); return true; // never reached } } private int convertToInteger(String value, String attributeName) { try { return Integer.parseInt(value); } catch (NumberFormatException e) { produceBadFormatException("integer", value, attributeName); return 0; // never reached } } private long convertToLong(String value, String attributeName) { try { return Long.parseLong(value); } catch (NumberFormatException e) { produceBadFormatException("long", value, attributeName); return 0; // never reached } } private float convertToFloat(String value, String attributeName) { try { return Float.parseFloat(value); } catch (NumberFormatException e) { produceBadFormatException("float", value, attributeName); return 0; // never reached } } private double convertToDouble(String value, String attributeName) { try { return Double.parseDouble(value); } catch (NumberFormatException e) { produceBadFormatException("double", value, attributeName); return 0; // never reached } } private void produceBadFormatException(String typeName, String value, String attributeName) { StringBuilder message = new StringBuilder(); message.append("Configuration value is not a valid ").append(typeName).append(": \"").append(value) .append("\""); if (attributeName == null) { message.append(" in configuration element ").append(getName()).append(" at ").append(getLocation()); } else { message.append(" in attribute ").append(attributeName).append(" of configuration element ") .append(getName()).append(" at ").append(getLocation()); } throw new ConfException(message.toString()); } public Inheritance getInheritance() { return inheritance; } public void setInheritance(Inheritance inheritance) { this.inheritance = inheritance; } public String getInheritConstraint() { return inheritConstraint; } public void setInheritConstraint(String inheritConstraint) { this.inheritConstraint = inheritConstraint; } public void inherit(ConfImpl parent) { inherit(parent, Inheritance.NONE); } public void inherit(ConfImpl parent, Inheritance defaultInheritance) { // In case of deep inheritance, we let our children inherit from the corresponding // children of the parent. // // But what are corresponding children? // // - in case there is an inheritance constraint defined, we take the first child // from the parent which has the same value for the inheritance constraint. // // - otherwise, corresponding children are children with the same name, thus // an inheritance constraint "local-name()" // // Note that performance is not very critical of this routine, as it is supposed // that (inherited) configurations are cached. // // Note that we first perform inheritance for our children (= deep inheritance), // before ourselve, to avoid that we would do deep inheritance on our inherited // children too. Inheritance inheritance = this.inheritance != null ? this.inheritance : defaultInheritance; String inheritConstraint = this.inheritConstraint != null ? this.inheritConstraint : "local-name()"; if (inheritance == Inheritance.DEEP && inheritConstraint.length() != 0) { for (ConfImpl child : children) { String key = evalInheritanceConstraint(child, inheritConstraint); for (ConfImpl parentChild : parent.children) { String parentKey = evalInheritanceConstraint(parentChild, inheritConstraint); if (key.equals(parentKey)) { child.inherit(parentChild, inheritance); break; } } } } if (inheritance != Inheritance.NONE) { // Inherit attributes for (Map.Entry<String, String> attr : parent.getAttributes().entrySet()) { if (!attributes.containsKey(attr.getKey())) { addAttribute(attr.getKey(), attr.getValue()); } } // Calculate the set of keys for the current children Set<String> presentKeys = null; if (inheritConstraint.length() != 0) { presentKeys = new HashSet<String>(); for (Conf conf : children) { String value = evalInheritanceConstraint(conf, inheritConstraint); if (value != null) { presentKeys.add(value); } } } // Inherit child elements for (ConfImpl conf : parent.children) { if (inheritConstraint.length() == 0) { // empty inherit constraint means: inherit everything children.add(conf.deepClone()); } else { String key = evalInheritanceConstraint(conf, inheritConstraint); if (key != null && !presentKeys.contains(key)) { children.add(conf.deepClone()); presentKeys.add(key); } } } } } public String evalInheritanceConstraint(Conf conf, String inheritConstraint) { try { JXPathContext jxpc = JXPathContext.newContext(conf); return (String) jxpc.getValue(inheritConstraint); } catch (Exception e) { throw new ConfException( "Error evaluating configuration inheritance uniqueness constraint expression: \"" + inheritConstraint + "\" on conf defined at " + conf.getLocation(), e); } } /** * Makes a deep clone of this Conf, the inheritance level * is however not cloned. */ public ConfImpl deepClone() { ConfImpl conf = new ConfImpl(name, location); conf.attributes.putAll(this.attributes); conf.value = value; for (ConfImpl childConf : children) { conf.children.add(childConf.deepClone()); } return conf; } }