diff options
Diffstat (limited to 'java/src/IceGridGUI/Utils.java')
| -rw-r--r-- | java/src/IceGridGUI/Utils.java | 484 |
1 files changed, 484 insertions, 0 deletions
diff --git a/java/src/IceGridGUI/Utils.java b/java/src/IceGridGUI/Utils.java new file mode 100644 index 00000000000..be9603315e9 --- /dev/null +++ b/java/src/IceGridGUI/Utils.java @@ -0,0 +1,484 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +package IceGridGUI; + +import javax.swing.ImageIcon; +import IceGrid.*; + +public class Utils +{ + static public ImageIcon getIcon(String path) + { + java.net.URL imgURL = Utils.class.getResource(path); + if(imgURL == null) + { + System.err.println("Could not find icon " + path); + return null; + } + else + { + return new ImageIcon(imgURL); + } + } + + // + // Extract Ice version in the form XXYYZZ, e.g. 030201 (for 3.2.1) + // 0 == empty string + // -1 == error + // + static public int getIntVersion(String version) + { + int result = 0; + version = version.trim(); + if(version.length() > 0) + { + try + { + int firstDotPos = version.indexOf('.'); + + if(firstDotPos == -1) + { + result = -1; + } + else + { + result = Integer.parseInt(version.substring(0, firstDotPos)); + if(result == 0) + { + return -1; + } + result *= 100; + + int secondDotPos = version.indexOf('.', firstDotPos + 1); + if(secondDotPos == -1) + { + result += Integer.parseInt(version.substring(firstDotPos + 1)); + result *= 100; + } + else + { + result += Integer.parseInt(version.substring(firstDotPos + 1, secondDotPos)); + result *= 100; + result += Integer.parseInt(version.substring(secondDotPos + 1)); + } + } + } + catch(NumberFormatException e) + { + result = -1; + } + } + return result; + } + + static public interface Stringifier + { + public String toString(Object obj); + } + + // + // Stringify helpers + // + static public String stringify(java.util.Collection<?> col, + Stringifier stringifier, + String separator, + Ice.StringHolder toolTipHolder) + { + String result = ""; + if(toolTipHolder != null) + { + toolTipHolder.value = null; + } + + java.util.Iterator<?> p = col.iterator(); + + boolean firstElement = true; + while(p.hasNext()) + { + String elt = stringifier.toString(p.next()); + if(elt != null) + { + if(firstElement) + { + firstElement = false; + if(toolTipHolder != null) + { + toolTipHolder.value = "<html>"; + } + } + else + { + result += separator; + if(toolTipHolder != null) + { + toolTipHolder.value += "<br>"; + } + } + + if(elt.length() == 0) + { + result += "\"\""; + } + else if(elt.matches("\\S*")) + { + // + // Only non-whitespace characters + // + result += elt; + } + else + { + result += '"' + elt + '"'; + } + + if(toolTipHolder != null) + { + toolTipHolder.value += elt; + } + } + } + if(toolTipHolder != null && toolTipHolder.value != null) + { + toolTipHolder.value += "</html>"; + } + + return result; + } + + static public String stringify(java.util.Collection<?> col, String separator, Ice.StringHolder toolTipHolder) + { + + Stringifier stringifier = new Stringifier() + { + public String toString(Object obj) + { + return (String)obj; + } + }; + return stringify(col, stringifier, separator, toolTipHolder); + + } + + static public String stringify(String[] stringSeq, String separator, Ice.StringHolder toolTipHolder) + { + + return stringify(java.util.Arrays.asList(stringSeq), separator, toolTipHolder); + } + + static public String stringify(java.util.Map<String, String> stringMap, + final String pairSeparator, + String separator, + Ice.StringHolder toolTipHolder) + { + Stringifier stringifier = new Stringifier() + { + public String toString(Object obj) + { + @SuppressWarnings("unchecked") + java.util.Map.Entry<String, String> entry = (java.util.Map.Entry<String, String>)obj; + return entry.getKey() + pairSeparator + entry.getValue(); + } + }; + + return stringify(stringMap.entrySet(), stringifier, separator, toolTipHolder); + } + + static public class Resolver + { + // + // Application-level resolver + // + @SuppressWarnings("unchecked") + public Resolver(java.util.Map<String, String> variables) + { + //@SuppressWarnings("unchecked") - unchecked conversion + this(new java.util.Map[]{variables}); + } + + public Resolver(java.util.Map<String, String>[] variables) + { + _variables = variables; + _predefinedVariables = new java.util.HashMap<String, String>(); + + _parameters = null; + _subResolver = this; + } + + // + // Resolver for instance; in-parameters are not yet substituted + // + public Resolver(Resolver parent, java.util.Map<String, String> parameters, + java.util.Map<String, String> defaults) + { + _variables = parent._variables; + + // + // Whenever the parent's predefined variables change, the resolver + // must be recreated + // + reset(parent, parameters, defaults); + } + + // + // Resolver for plain server or service + // + public Resolver(Resolver parent) + { + _variables = parent._variables; + _predefinedVariables = new java.util.HashMap<String, String>(parent._predefinedVariables); + _parameters = parent._parameters; + if(_parameters == null) + { + _subResolver = this; + } + else + { + _subResolver = new Resolver(_variables, _predefinedVariables); + } + } + + private Resolver(java.util.Map<String, String>[] variables, java.util.Map<String, String> predefinedVariables) + { + _variables = variables; + _predefinedVariables = predefinedVariables; + + _parameters = null; + _subResolver = this; + } + + public String find(String name) + { + if(_parameters != null) + { + String val = _parameters.get(name); + if(val != null) + { + return val; + } + } + + String val = _predefinedVariables.get(name); + if(val != null) + { + return val; + } + + for(java.util.Map<String, String> map : _variables) + { + val = map.get(name); + if(val != null) + { + return _subResolver.substitute(val); + } + } + return null; + } + + // + // Set a pre-defined variable; returns true if value was updated + // + public boolean put(String name, String value) + { + String oldVal = _predefinedVariables.get(name); + if(oldVal == null || !oldVal.equals(value)) + { + _predefinedVariables.put(name, value); + return true; + } + else + { + return false; + } + } + + // + // Reset parameters and pre-defined variables + // + public void reset(Resolver parent, java.util.Map<String, String> parameters, + java.util.Map<String, String> defaults) + { + assert _variables == parent._variables; + _predefinedVariables = new java.util.HashMap<String, String>(parent._predefinedVariables); + + _parameters = parent.substituteParameterValues(parameters, defaults); + _subResolver = new Resolver(_variables, _predefinedVariables); + } + + public void reset(Resolver parent) + { + assert _variables == parent._variables; + _predefinedVariables = new java.util.HashMap<String, String>(parent._predefinedVariables); + + assert _parameters == parent._parameters; + if(_parameters == null) + { + _subResolver = this; + } + else + { + _subResolver = new Resolver(_variables, _predefinedVariables); + } + } + + // + // The sorted substituted parameters + // + public java.util.Map<String, String> getParameters() + { + return _parameters; + } + + public String substitute(String input) + { + if(input == null) + { + return input; + } + + int beg = 0; + int end = 0; + + while((beg = input.indexOf("${", beg)) != -1) + { + if(beg > 0 && input.charAt(beg - 1) == '$') + { + int escape = beg - 1; + while(escape > 0 && input.charAt(escape - 1) == '$') + { + --escape; + } + + input = input.substring(0, escape) + input.substring(beg - (beg - escape) / 2); + if((beg - escape) % 2 != 0) + { + ++beg; + continue; + } + else + { + beg -= (beg - escape) / 2; + } + } + + end = input.indexOf('}', beg); + if(end == -1) + { + // + // Malformed variable, can't substitute anything else + // + return input; + } + + String name = input.substring(beg + 2, end); + + // + // Resolve name + // + String val = find(name); + if(val != null) + { + input = input.substring(0, beg) + val + input.substring(end + 1); + beg += val.length(); + } + else + { + // + // No substitution, keep ${name} in the result + // + ++beg; + } + } + return input; + } + + // + // Substitute all the values from the input map + // + public java.util.Map<String, String> substituteParameterValues(java.util.Map<String, String> input, + java.util.Map<String, String> defaults) + { + java.util.Map<String, String> result = new java.util.HashMap<String, String>(); + for(java.util.Map.Entry<String, String> p : input.entrySet()) + { + result.put(p.getKey(), substitute(p.getValue())); + } + for(java.util.Map.Entry<String, String> p : defaults.entrySet()) + { + if(!result.containsKey(p.getKey())) + { + result.put(p.getKey(), substitute(p.getValue())); + } + } + return result; + } + + private java.util.Map<String, String>[] _variables; + private java.util.Map<String, String> _parameters; + private java.util.Map<String, String> _predefinedVariables; + + private Resolver _subResolver; + } + + static public String substitute(String input, Resolver resolver) + { + if(resolver != null) + { + return resolver.substitute(input); + } + else + { + return input; + } + } + + // + // An expanded property set (i.e. containing other property sets) + // + static public class ExpandedPropertySet + { + public ExpandedPropertySet[] references; + public java.util.List<PropertyDescriptor> properties; // list of PropertyDescriptor + } + + static public java.util.SortedMap<String, String> propertySetsToMap( + java.util.List<ExpandedPropertySet> propertySets, + Resolver resolver) + { + java.util.SortedMap<String, String> toMap = new java.util.TreeMap<String, String>(); + for(ExpandedPropertySet p : propertySets) + { + addSet(p, resolver, toMap); + } + return toMap; + } + + static public java.util.SortedMap<String, String> + propertySetToMap(ExpandedPropertySet propertySet, Resolver resolver) + { + java.util.List<ExpandedPropertySet> list = new java.util.LinkedList<ExpandedPropertySet>(); + list.add(propertySet); + return propertySetsToMap(list, resolver); + } + + static private void addSet(ExpandedPropertySet set, Resolver resolver, java.util.SortedMap<String, String> toMap) + { + for(ExpandedPropertySet s : set.references) + { + addSet(s, resolver, toMap); + } + + for(PropertyDescriptor p : set.properties) + { + String name = substitute(p.name, resolver); + String val = substitute(p.value, resolver); + toMap.put(name, val); + } + } +} |