+ * This method performs property variable substitution on the + * specified value. If the specified value contains the syntax + * {@code ${<prop-name>}}, where {@code <prop-name>} + * refers to either a configuration property or a system property, + * then the corresponding property value is substituted for the variable + * placeholder. Multiple variable placeholders may exist in the + * specified value as well as nested variable placeholders, which + * are substituted from inner most to outer most. Configuration + * properties override system properties. + *
+ * + * @param val The string on which to perform property substitution. + * @param currentKey The key of the property being evaluated used to + * detect cycles. + * @param cycleMap Map of variable references used to detect nested cycles. + * @param configProps Set of configuration properties. + * @return The value of the specified string after system property substitution. + * @throws IllegalArgumentException If there was a syntax error in the + * property placeholder syntax or a recursive variable reference. + **/ + public static String substVars( + String val, String currentKey, Map+ * This method performs property variable substitution on the + * specified value. If the specified value contains the syntax + * {@code ${<prop-name>}}, where {@code <prop-name>} + * refers to either a configuration property or a system property, + * then the corresponding property value is substituted for the variable + * placeholder. Multiple variable placeholders may exist in the + * specified value as well as nested variable placeholders, which + * are substituted from inner most to outer most. Configuration + * properties override system properties. + *
+ * + * @param val The string on which to perform property substitution. + * @param currentKey The key of the property being evaluated used to + * detect cycles. + * @param cycleMap Map of variable references used to detect nested cycles. + * @param configProps Set of configuration properties. + * @param callback the callback to obtain substitution values + * @return The value of the specified string after system property substitution. + * @throws IllegalArgumentException If there was a syntax error in the + * property placeholder syntax or a recursive variable reference. + **/ + public static String substVars( + String val, + String currentKey, + Map+ * This method performs property variable substitution on the + * specified value. If the specified value contains the syntax + * {@code ${<prop-name>}}, where {@code <prop-name>} + * refers to either a configuration property or a system property, + * then the corresponding property value is substituted for the variable + * placeholder. Multiple variable placeholders may exist in the + * specified value as well as nested variable placeholders, which + * are substituted from inner most to outer most. Configuration + * properties override system properties. + *
+ * + * @param val The string on which to perform property substitution. + * @param currentKey The key of the property being evaluated used to + * detect cycles. + * @param cycleMap Map of variable references used to detect nested cycles. + * @param configProps Set of configuration properties. + * @param callback the callback to obtain substitution values + * @param substituteFromConfig If substitute from configuration + * @param substituteFromSystemProperties If substitute from system properties + * @param defaultsToEmptyString sets an empty string if a replacement value is not found, leaves intact otherwise + * @return The value of the specified string after system property substitution. + * @throws IllegalArgumentException If there was a syntax error in the + * property placeholder syntax or a recursive variable reference. + **/ + public static String substVars( + String val, + String currentKey, + MapProperties
+ * managing the maintain of comments, etc.
+ */
+public class Properties extends AbstractMapUnescapes any Java literals found in the String to a
+ * Writer.
String to unescape, may be null
+ * @return the processed string
+ * @throws IllegalArgumentException if the Writer is null
+ */
+ protected static String unescapeJava(String str) {
+ if (str == null) {
+ return null;
+ }
+ int sz = str.length();
+ StringBuilder out = new StringBuilder(sz);
+ StringBuilder unicode = new StringBuilder(UNICODE_LEN);
+ boolean hadSlash = false;
+ boolean inUnicode = false;
+ for (int i = 0; i < sz; i++) {
+ char ch = str.charAt(i);
+ if (inUnicode) {
+ // if in unicode, then we're reading unicode
+ // values in somehow
+ unicode.append(ch);
+ if (unicode.length() == UNICODE_LEN) {
+ // unicode now contains the four hex digits
+ // which represents our unicode character
+ try {
+ int value = Integer.parseInt(unicode.toString(), HEX_RADIX);
+ out.append((char) value);
+ unicode.setLength(0);
+ inUnicode = false;
+ hadSlash = false;
+ } catch (NumberFormatException nfe) {
+ throw new IllegalArgumentException("Unable to parse unicode value: " + unicode, nfe);
+ }
+ }
+ continue;
+ }
+
+ if (hadSlash) {
+ // handle an escaped value
+ hadSlash = false;
+ switch (ch) {
+ case '\\':
+ out.append('\\');
+ break;
+ case '\'':
+ out.append('\'');
+ break;
+ case '\"':
+ out.append('"');
+ break;
+ case 'r':
+ out.append('\r');
+ break;
+ case 'f':
+ out.append('\f');
+ break;
+ case 't':
+ out.append('\t');
+ break;
+ case 'n':
+ out.append('\n');
+ break;
+ case 'b':
+ out.append('\b');
+ break;
+ case 'u':
+ // uh-oh, we're in unicode country....
+ inUnicode = true;
+ break;
+ default:
+ out.append(ch);
+ break;
+ }
+ continue;
+ } else if (ch == '\\') {
+ hadSlash = true;
+ continue;
+ }
+ out.append(ch);
+ }
+
+ if (hadSlash) {
+ // then we're in the weird case of a \ at the end of the
+ // string, let's output it anyway.
+ out.append('\\');
+ }
+
+ return out.toString();
+ }
+
+ /**
+ * Escapes the characters in a String using Java String rules.
Deals correctly with quotes and control-chars (tab, backslash, cr, ff, etc.)
+ * + *So a tab becomes the characters '\\' and
+ * 't'.
The only difference between Java strings and JavaScript strings + * is that in JavaScript, a single quote must be escaped.
+ * + *Example:
+ *+ * input string: He didn't say, "Stop!" + * output string: He didn't say, \"Stop!\" + *+ * + * + * @param str String to escape values in, may be null + * @return String with escaped values,
null if null string input
+ */
+ @SuppressWarnings("checkstyle:MagicNumber")
+ protected static String escapeJava(String str) {
+ if (str == null) {
+ return null;
+ }
+ int sz = str.length();
+ StringBuilder out = new StringBuilder(sz * 2);
+ for (int i = 0; i < sz; i++) {
+ char ch = str.charAt(i);
+ // handle unicode
+ if (ch > 0xfff) {
+ out.append("\\u").append(hex(ch));
+ } else if (ch > 0xff) {
+ out.append("\\u0").append(hex(ch));
+ } else if (ch > 0x7f) {
+ out.append("\\u00").append(hex(ch));
+ } else if (ch < 32) {
+ switch (ch) {
+ case '\b':
+ out.append('\\');
+ out.append('b');
+ break;
+ case '\n':
+ out.append('\\');
+ out.append('n');
+ break;
+ case '\t':
+ out.append('\\');
+ out.append('t');
+ break;
+ case '\f':
+ out.append('\\');
+ out.append('f');
+ break;
+ case '\r':
+ out.append('\\');
+ out.append('r');
+ break;
+ default:
+ if (ch > 0xf) {
+ out.append("\\u00").append(hex(ch));
+ } else {
+ out.append("\\u000").append(hex(ch));
+ }
+ break;
+ }
+ } else {
+ switch (ch) {
+ case '"':
+ out.append('\\');
+ out.append('"');
+ break;
+ case '\\':
+ out.append('\\');
+ out.append('\\');
+ break;
+ default:
+ out.append(ch);
+ break;
+ }
+ }
+ }
+ return out.toString();
+ }
+
+ /**
+ * Returns an upper case hexadecimal String for the given
+ * character.
String
+ */
+ protected static String hex(char ch) {
+ return Integer.toHexString(ch).toUpperCase(Locale.ENGLISH);
+ }
+
+ /**
+ * Checks if the value is in the given array.
+ * + *The method returns false if a null array is passed in.
true if the array contains the object
+ */
+ public static boolean contains(char[] array, char valueToFind) {
+ if (array == null) {
+ return false;
+ }
+ for (char c : array) {
+ if (valueToFind == c) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Escape the separators in the key.
+ *
+ * @param key the key
+ * @return the escaped key
+ */
+ private static String escapeKey(String key) {
+ StringBuilder newkey = new StringBuilder();
+
+ for (int i = 0; i < key.length(); i++) {
+ char c = key.charAt(i);
+
+ if (contains(SEPARATORS, c) || contains(WHITE_SPACE, c)) {
+ // escape the separator
+ newkey.append('\\');
+ newkey.append(c);
+ } else {
+ newkey.append(c);
+ }
+ }
+
+ return newkey.toString();
+ }
+
+ /**
+ * This class is used to read properties lines. These lines do
+ * not terminate with new-line chars but rather when there is no
+ * backslash sign a the end of the line. This is used to
+ * concatenate multiple lines for readability.
+ */
+ public static class PropertiesReader extends LineNumberReader {
+ /** Stores the comment lines for the currently processed property.*/
+ private final ListPropertiesReader and sets
+ * the underlaying reader and the list delimiter.
+ *
+ * @param reader the reader
+ */
+ public PropertiesReader(Reader reader, boolean maybeTyped) {
+ super(reader);
+ commentLines = new ArrayList<name>
+ * = <value>)
+ *
+ * @return A string containing a property value or null
+ *
+ * @throws IOException in case of an I/O error
+ */
+ public String readProperty() throws IOException {
+ commentLines.clear();
+ valueLines.clear();
+ StringBuilder buffer = new StringBuilder();
+
+ while (true) {
+ String line = readLine();
+ if (line == null) {
+ // EOF
+ return null;
+ }
+
+ if (isCommentLine(line)) {
+ commentLines.add(line);
+ continue;
+ }
+
+ boolean combine = checkCombineLines(line);
+ if (combine) {
+ line = line.substring(0, line.length() - 1);
+ }
+ valueLines.add(line);
+ while (line.length() > 0 && contains(WHITE_SPACE, line.charAt(0))) {
+ line = line.substring(1, line.length());
+ }
+ buffer.append(line);
+ if (!combine) {
+ break;
+ }
+ }
+ return buffer.toString();
+ }
+
+ /**
+ * Parses the next property from the input stream and stores the found
+ * name and value in internal fields. These fields can be obtained using
+ * the provided getter methods. The return value indicates whether EOF
+ * was reached (false) or whether further properties are
+ * available (true).
+ *
+ * @return a flag if further properties are available
+ * @throws IOException if an error occurs
+ */
+ public boolean nextProperty() throws IOException {
+ String line = readProperty();
+
+ if (line == null) {
+ return false; // EOF
+ }
+
+ // parse the line
+ String[] property = parseProperty(line);
+ boolean typed = false;
+ if (maybeTyped && property[1].length() >= 2) {
+ typed = property[1].matches(
+ "\\s*[TILFDXSCBilfdxscb]?(\\[[\\S\\s]*\\]|\\([\\S\\s]*\\)|\\{[\\S\\s]*\\}|\"[\\S\\s]*\")\\s*");
+ }
+ if (this.typed == null) {
+ this.typed = typed;
+ } else {
+ this.typed = this.typed & typed;
+ }
+ propertyName = unescapeJava(property[0]);
+ propertyValue = property[1];
+ return true;
+ }
+
+ /**
+ * Returns the comment lines that have been read for the last property.
+ *
+ * @return the comment lines for the last property returned by
+ * readProperty()
+ */
+ public ListreadProperty()
+ */
+ public List{@link #nextProperty()} was invoked and its
+ * return value was true.
+ *
+ * @return the name of the last read property
+ */
+ public String getPropertyName() {
+ return propertyName;
+ }
+
+ /**
+ * Returns the value of the last read property. This method can be
+ * called after {@link #nextProperty()} was invoked and
+ * its return value was true.
+ *
+ * @return the value of the last read property
+ */
+ public String getPropertyValue() {
+ return propertyValue;
+ }
+
+ /**
+ * Checks if the passed in line should be combined with the following.
+ * This is true, if the line ends with an odd number of backslashes.
+ *
+ * @param line the line
+ * @return a flag if the lines should be combined
+ */
+ private static boolean checkCombineLines(String line) {
+ int bsCount = 0;
+ for (int idx = line.length() - 1; idx >= 0 && line.charAt(idx) == '\\'; idx--) {
+ bsCount++;
+ }
+
+ return bsCount % 2 != 0;
+ }
+
+ /**
+ * Parse a property line and return the key and the value in an array.
+ *
+ * @param line the line to parse
+ * @return an array with the property's key and value
+ */
+ private static String[] parseProperty(String line) {
+ // sorry for this spaghetti code, please replace it as soon as
+ // possible with a regexp when the Java 1.3 requirement is dropped
+
+ String[] result = new String[2];
+ StringBuilder key = new StringBuilder();
+ StringBuilder value = new StringBuilder();
+
+ // state of the automaton:
+ // 0: key parsing
+ // 1: antislash found while parsing the key
+ // 2: separator crossing
+ // 3: white spaces
+ // 4: value parsing
+ int state = 0;
+
+ for (int pos = 0; pos < line.length(); pos++) {
+ char c = line.charAt(pos);
+
+ switch (state) {
+ case 0:
+ if (c == '\\') {
+ state = 1;
+ } else if (contains(WHITE_SPACE, c)) {
+ // switch to the separator crossing state
+ state = 2;
+ } else if (contains(SEPARATORS, c)) {
+ // switch to the value parsing state
+ state = 3;
+ } else {
+ key.append(c);
+ }
+
+ break;
+
+ case 1:
+ if (contains(SEPARATORS, c) || contains(WHITE_SPACE, c)) {
+ // this is an escaped separator or white space
+ key.append(c);
+ } else {
+ // another escaped character, the '\' is preserved
+ key.append('\\');
+ key.append(c);
+ }
+
+ // return to the key parsing state
+ state = 0;
+
+ break;
+
+ case 2:
+ if (contains(WHITE_SPACE, c)) {
+ // do nothing, eat all white spaces
+ state = 2;
+ } else if (contains(SEPARATORS, c)) {
+ // switch to the value parsing state
+ state = 3;
+ } else {
+ // any other character indicates we encoutered the beginning of the value
+ value.append(c);
+
+ // switch to the value parsing state
+ state = 4;
+ }
+
+ break;
+
+ case 3:
+ if (contains(WHITE_SPACE, c)) {
+ // do nothing, eat all white spaces
+ state = 3;
+ } else {
+ // any other character indicates we encoutered the beginning of the value
+ value.append(c);
+
+ // switch to the value parsing state
+ state = 4;
+ }
+
+ break;
+
+ case 4:
+ value.append(c);
+ break;
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+
+ result[0] = key.toString();
+ result[1] = value.toString();
+
+ return result;
+ }
+ } // class PropertiesReader
+
+ /**
+ * This class is used to write properties lines.
+ */
+ public static class PropertiesWriter extends FilterWriter {
+ private boolean typed;
+
+ /**
+ * Constructor.
+ *
+ * @param writer a Writer object providing the underlying stream
+ */
+ public PropertiesWriter(Writer writer, boolean typed) {
+ super(writer);
+ this.typed = typed;
+ }
+
+ /**
+ * Writes the given property and its value.
+ *
+ * @param key the property key
+ * @param value the property value
+ * @throws IOException if an error occurs
+ */
+ public void writeProperty(String key, String value) throws IOException {
+ write(escapeKey(key));
+ write(" = ");
+ write(typed ? value : escapeJava(value));
+ writeln(null);
+ }
+
+ /**
+ * Helper method for writing a line with the platform specific line
+ * ending.
+ *
+ * @param s the content of the line (may be null)
+ * @throws IOException if an error occurs
+ */
+ public void writeln(String s) throws IOException {
+ if (s != null) {
+ write(s);
+ }
+ write(LINE_SEPARATOR);
+ }
+ } // class PropertiesWriter
+
+ /**
+ * TODO
+ */
+ protected static class Layout {
+
+ private List