/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.openejb.util;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringReader;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.InvalidPropertiesFormatException;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* Properties is a Hashtable where the keys and values must be Strings. Each Properties can have a default
* Properties which specifies the default values which are used if the key is not in this Properties.
*
* @see Hashtable
* @see java.lang.System#getProperties
*/
public class SuperProperties extends Properties {
private static final String PROP_DTD_NAME = "http://java.sun.com/dtd/properties.dtd";
private static final String PROP_DTD = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ " <!ELEMENT properties (comment?, entry*) >"
+ " <!ATTLIST properties version CDATA #FIXED \"1.0\" >"
+ " <!ELEMENT comment (#PCDATA) >"
+ " <!ELEMENT entry (#PCDATA) >"
+ " <!ATTLIST entry key CDATA #REQUIRED >";
/**
* Actual property values.
*/
protected LinkedHashMap<Object,Object> properties = new LinkedHashMap<Object,Object>();
/**
* Comments for individual the properties.
*/
protected LinkedHashMap<String,String> comments = new LinkedHashMap<String,String>();
/**
* Attributes for the properties.
*/
protected LinkedHashMap<String,LinkedHashMap<String,String>> attributes = new LinkedHashMap<String,LinkedHashMap<String,String>>();
/**
* The default property values.
*/
protected Properties defaults;
/**
* Are lookups case insensitive?
*/
protected boolean caseInsensitive;
/**
* The text between a key and the value.
*/
protected String keyValueSeparator = "=";
/**
* The line separator to use when storing. Defaults to system line separator.
*/
protected String lineSeparator = System.getProperty("line.separator");
/**
* Number of spaces to indent each line of the properties file.
*/
protected String indent = "";
/**
* Number of spaces to indent comment after '#' character.
*/
protected String commentIndent = " ";
/**
* Should there be a blank line between properties.
*/
protected boolean spaceBetweenProperties = true;
/**
* Should there be a blank line between a comment and the property.
*/
protected boolean spaceAfterComment = false;
/**
* Used for loadFromXML.
*/
private DocumentBuilder builder = null;
/**
* Constructs a new Properties object.
*/
public SuperProperties() {
super();
}
/**
* Constructs a new Properties object using the specified default properties.
*
* @param properties the default properties
*/
public SuperProperties(Properties properties) {
super(properties);
defaults = properties;
}
/**
* Are lookups case insensitive?
* @return true if lookups are insensitive
*/
public boolean isCaseInsensitive() {
return caseInsensitive;
}
/**
* Sets the sensitive of lookups.
* @param caseInsensitive if looks are insensitive
*/
public void setCaseInsensitive(boolean caseInsensitive) {
this.caseInsensitive = caseInsensitive;
}
/**
* Gets the text that separates keys and values.
* The default is "=".
* @return the text that separates keys and values
*/
public String getKeyValueSeparator() {
return keyValueSeparator;
}
/**
* Sets the text that separates keys and values.
* @param keyValueSeparator the text that separates keys and values
*/
public void setKeyValueSeparator(String keyValueSeparator) {
if (keyValueSeparator == null) throw new NullPointerException("keyValueSeparator is null");
if (keyValueSeparator.length() == 0) throw new NullPointerException("keyValueSeparator is empty");
this.keyValueSeparator = keyValueSeparator;
}
/**
* Gets the text that separates lines while storing.
* The default is the system line.separator.
* @return the text that separates keys and values
*/
public String getLineSeparator() {
return lineSeparator;
}
/**
* Sets the text that separates lines while storing
* @param lineSeparator the text that separates lines
*/
public void setLineSeparator(String lineSeparator) {
if (lineSeparator == null) throw new NullPointerException("lineSeparator is null");
if (lineSeparator.length() == 0) throw new NullPointerException("lineSeparator is empty");
this.lineSeparator = lineSeparator;
}
/**
* Gets the number of spaces to indent each line of the properties file.
* @return the number of spaces to indent each line of the properties file
*/
public int getIndent() {
return indent.length();
}
/**
* Sets the number of spaces to indent each line of the properties file.
* @param indent the number of spaces to indent each line of the properties file
*/
public void setIndent(int indent) {
char[] chars = new char[indent];
Arrays.fill(chars, ' ');
this.indent = new String(chars);
}
/**
* Gets the number of spaces to indent comment after '#' character.
* @return the number of spaces to indent comment after '#' character
*/
public int getCommentIndent() {
return commentIndent.length();
}
/**
* Sets the number of spaces to indent comment after '#' character.
* @param commentIndent the number of spaces to indent comment after '#' character
*/
public void setCommentIndent(int commentIndent) {
char[] chars = new char[commentIndent];
Arrays.fill(chars, ' ');
this.commentIndent = new String(chars);
}
/**
* Should a blank line be added between properties?
* @return true if a blank line should be added between properties; false otherwise
*/
public boolean isSpaceBetweenProperties() {
return spaceBetweenProperties;
}
/**
* If true a blank line will be added between properties.
* @param spaceBetweenProperties if true a blank line will be added between properties
*/
public void setSpaceBetweenProperties(boolean spaceBetweenProperties) {
this.spaceBetweenProperties = spaceBetweenProperties;
}
/**
* Should there be a blank line between a comment and the property?
* @return true if a blank line should be added between a comment and the property
*/
public boolean isSpaceAfterComment() {
return spaceAfterComment;
}
/**
* If true a blank line will be added between a comment and the property.
* @param spaceAfterComment if true a blank line will be added between a comment and the property
*/
public void setSpaceAfterComment(boolean spaceAfterComment) {
this.spaceAfterComment = spaceAfterComment;
}
public String getProperty(String name) {
Object result = get(name);
String property = result instanceof String ? (String) result : null;
if (property == null && defaults != null) {
property = defaults.getProperty(name);
}
return property;
}
public String getProperty(String name, String defaultValue) {
Object result = get(name);
String property = result instanceof String ? (String) result : null;
if (property == null && defaults != null) {
property = defaults.getProperty(name);
}
if (property == null) {
return defaultValue;
}
return property;
}
public synchronized Object setProperty(String name, String value) {
return put(name, value);
}
/**
* Searches for the comment associated with the specified property. If the property is not found, look
* in the default properties. If the property is not found in the default properties, answer null.
*
* @param name the name of the property to find
* @return the named property value
*/
public String getComment(String name) {
name = normalize(name);
String comment = comments.get(name);
if (comment == null && defaults instanceof SuperProperties) {
comment = ((SuperProperties) defaults).getComment(name);
}
return comment;
}
/**
* Sets the comment associated with a property.
* @param name the property name; not null
* @param comment the comment; not null
*/
public void setComment(String name, String comment) {
if (name == null) throw new NullPointerException("name is null");
if (comment == null) throw new NullPointerException("comment is null");
name = normalize(name);
comments.put(name, comment);
}
/**
* Searches for the attributes associated with the specified property. If the property is not found, look
* in the default properties. If the property is not found in the default properties, answer null.
*
* @param name the name of the property to find
* @return the attributes for an existing property (not null); null for non-existant properties
*/
public Map<String,String> getAttributes(String name) {
if (name == null) throw new NullPointerException("name is null");
name = normalize(name);
Map<String, String> attributes = this.attributes.get(name);
if (attributes == null && defaults instanceof SuperProperties) {
attributes = ((SuperProperties) defaults).getAttributes(name);
}
return attributes;
}
public void list(PrintStream out) {
if (out == null) {
throw new NullPointerException();
}
StringBuilder buffer = new StringBuilder(80);
Enumeration<?> keys = propertyNames();
while (keys.hasMoreElements()) {
String key = (String) keys.nextElement();
buffer.append(key);
buffer.append('=');
String property = (String) get(key);
if (property == null) {
property = defaults.getProperty(key);
}
if (property.length() > 40) {
buffer.append(property.substring(0, 37));
buffer.append("...");
} else {
buffer.append(property);
}
out.println(buffer.toString());
buffer.setLength(0);
}
}
public void list(PrintWriter writer) {
if (writer == null) {
throw new NullPointerException();
}
StringBuilder buffer = new StringBuilder(80);
Enumeration<?> keys = propertyNames();
while (keys.hasMoreElements()) {
String key = (String) keys.nextElement();
buffer.append(key);
buffer.append('=');
String property = (String) get(key);
while (property == null) {
property = defaults.getProperty(key);
}
if (property.length() > 40) {
buffer.append(property.substring(0, 37));
buffer.append("...");
} else {
buffer.append(property);
}
writer.println(buffer.toString());
buffer.setLength(0);
}
}
public synchronized void load(InputStream in) throws IOException {
// never null, when empty we are processing the white space at the beginning of the line
StringBuilder key = new StringBuilder();
// null when processing key
StringBuilder value = null;
// never null, contains the comment for the property or nothing if no comment
StringBuilder comment = new StringBuilder();
// never null, contains attributes for a property
LinkedHashMap<String,String> attributes = new LinkedHashMap<String,String>();
int indent = 0;
boolean globalIndentSet = false;
int commentIndent = -1;
boolean globalCommentIndentSet = false;
// true when processing the separator between a key and value
boolean inSeparator = false;
while (true) {
int nextByte = decodeNextCharacter(in);
if (nextByte == EOF) break;
char nextChar = (char) (nextByte & 0xff);
switch (nextByte) {
case ' ':
case '\t':
//
// End of key if parsing key
//
// if parsing the key, this is the end of the key
if (key.length() > 0 && value == null) {
inSeparator = true;
value = new StringBuilder();
continue;
}
break;
case ':':
case '=':
//
// End of key
//
if (inSeparator) {
inSeparator = false;
continue;
}
if (value == null) {
value = new StringBuilder();
continue;
}
break;
case LINE_ENDING:
//
// End of Line
//
if (key.length() > 0) {
// add property
put(key.toString(), value == null ? "" : value.toString());
// add comment
if (comment.length() > 0) {
setComment(key.toString(), comment.toString());
comment = new StringBuilder();
}
// add attributes
this.attributes.put(normalize(key.toString()), attributes);
attributes = new LinkedHashMap<String,String>();
// set line indent
if (!globalIndentSet) {
setIndent(indent);
globalIndentSet = true;
}
indent = 0;
}
key = new StringBuilder();
value = null;
continue;
case '#':
case '!':
//
// Comment
//
if (key.length() == 0) {
// set global line indent
if (!globalIndentSet) {
setIndent(indent);
globalIndentSet = true;
}
indent = 0;
// read comment Line
StringBuilder commentLine = new StringBuilder();
int commentLineIndent = 0;
boolean inIndent = true;
while (true) {
nextByte = in.read();
if (nextByte < 0) break;
nextChar = (char) nextByte; // & 0xff
if (inIndent && nextChar == ' ') {
commentLineIndent++;
commentLine.append(' ');
} else if (inIndent && nextChar == '\t') {
commentLineIndent += 4;
commentLine.append(" ");
} else if (nextChar == '\r' || nextChar == '\n') {
break;
} else {
inIndent = false;
commentLine.append(nextChar);
}
}
// Determine indent
if (comment.length() == 0) {
// if this is a new comment block, the comment indent size for this
// block is based the first line of the comment
commentIndent = commentLineIndent;
if (!globalCommentIndentSet) {
setCommentIndent(commentIndent);
globalCommentIndentSet = true;
}
}
commentLineIndent = Math.min(commentIndent, commentLineIndent);
if (commentLine.toString().trim().startsWith("@")) {
// process property attribute
String attribute = commentLine.toString().trim().substring(1);
String[] parts = attribute.split("=", 2);
String attributeName = parts[0].trim();
String attributeValue = parts.length == 2 ? parts[1].trim() : "";
attributes.put(attributeName, attributeValue);
} else {
// append comment
if (comment.length() != 0) {
comment.append(lineSeparator);
}
comment.append(commentLine.toString().substring(commentLineIndent));
}
continue;
}
break;
}
if (nextByte >= 0 && Character.isWhitespace(nextChar)) {
// count leading white space
if (key.length() == 0) {
if (nextChar == '\t') {
indent += 4;
} else {
indent++;
}
}
// if key length == 0 or value length == 0
if (key.length() == 0 || value == null || value.length() == 0) {
continue;
}
}
// Decode encoded separator characters
switch (nextByte) {
case ENCODED_EQUALS:
nextChar = '=';
break;
case ENCODED_COLON:
nextChar = ':';
break;
case ENCODED_SPACE:
nextChar = ' ';
break;
case ENCODED_TAB:
nextChar = '\t';
break;
case ENCODED_NEWLINE:
nextChar = '\n';
break;
case ENCODED_CARRIAGE_RETURN:
nextChar = '\r';
break;
}
inSeparator = false;
if (value == null) {
key.append(nextChar);
} else {
value.append(nextChar);
}
}
// if buffer has data, there is a property we still need toadd
if (key.length() > 0) {
// add property
put(key.toString(), value == null ? "" : value.toString());
// add comment
if (comment.length() > 0) {
setComment(key.toString(), comment.toString());
}
// add attributes
this.attributes.put(normalize(key.toString()), attributes);
// set line indent
if (!globalIndentSet) {
setIndent(indent);
}
}
}
private static final int EOF = -1;
private static final int LINE_ENDING = -4200;
private static final int ENCODED_EQUALS = -5000;
private static final int ENCODED_COLON = -5001;
private static final int ENCODED_SPACE = -5002;
private static final int ENCODED_TAB = -5003;
private static final int ENCODED_NEWLINE = -5004;
private static final int ENCODED_CARRIAGE_RETURN = -5005;
private int decodeNextCharacter(InputStream in) throws IOException {
boolean lineContinuation = false;
boolean carriageReturnLineContinuation = false;
boolean encoded = false;
while (true) {
// read character
int nextByte = in.read();
if (nextByte < 0) return EOF;
char nextChar = (char) (nextByte & 0xff);
// if line continuation character was '\r', we need to ignore an optional '\n'
// immediately following the \r
if (carriageReturnLineContinuation) {
carriageReturnLineContinuation = false;
if (nextChar == '\n') {
continue;
}
}
// If escape sequence \x or line continuation, decode it
if (nextChar == '\\') {
// next character is the escaped character
nextByte = in.read();
if (nextByte < 0) {
// line continuation to end of stream
// sun vm returns 0 character for this case
nextChar = '\u0000';
} else {
nextChar = (char) (nextByte & 0xff);
}
switch (nextChar) {
case '\r':
// line continuation using '\r', which optionally can have a following '\n'
carriageReturnLineContinuation = true;
// fall through
case '\n':
// line continuation
lineContinuation = true;
continue;
case 'u':
nextChar = readUnicode(in);
break;
default:
encoded = true;
nextChar = decodeEscapeChar(nextChar);
break;
}
} else {
// if line ending character, we return the special value LINE_ENDING so
// caller can differentiate between an encoded "\n" sequence and a real
// line ending character in the file
if (nextChar == '\n' || nextChar == '\r') {
return LINE_ENDING;
}
}
// in a line continuation we ignore spaces and tabs until the first real character
if (lineContinuation && (nextChar == ' ' || nextChar == '\t')) {
continue;
}
if (encoded) {
switch (nextChar) {
case '=':
return ENCODED_EQUALS;
case ':':
return ENCODED_COLON;
case ' ':
return ENCODED_SPACE;
case '\t':
return ENCODED_TAB;
case '\n':
return ENCODED_NEWLINE;
case '\r':
return ENCODED_CARRIAGE_RETURN;
}
}
return nextChar;
}
}
private char decodeEscapeChar(char nextChar) {
switch (nextChar) {
case 'b':
return '\b';
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'u':
throw new IllegalArgumentException("decodeEscapeChar can not decode an unicode sequence");
default:
return nextChar;
}
}
private char readUnicode(InputStream in) throws IOException {
char[] buf = new char[4];
int unicode = 0;
for (int i = 0; i < buf.length; i++) {
int nextByte = in.read();
// we must get exactally 4 bytes
if (nextByte < 0) {
throw new IllegalArgumentException("Invalid unicode sequence: expected format \\uxxxx, but got \\u" + new String(buf, 0, i));
}
// convert to character
char nextChar = (char) (nextByte & 0xff);
buf[i] = nextChar;
// convert to digit
int nextDigit = Character.digit(nextChar, 16);
// all bytes must be valid hex digits
if (nextDigit < 0) {
throw new IllegalArgumentException("Illegal character " + nextChar + " in unicode sequence \\u" + new String(buf, 0, i + 1));
}
unicode = (unicode << 4) + nextDigit;
}
return (char) unicode;
}
public Enumeration<?> propertyNames() {
if (defaults == null) {
return keys();
}
Hashtable<Object, Object> set = new Hashtable<Object, Object>(defaults.size() + size());
Enumeration<?> keys = defaults.propertyNames();
while (keys.hasMoreElements()) {
set.put(keys.nextElement(), set);
}
keys = keys();
while (keys.hasMoreElements()) {
set.put(keys.nextElement(), set);
}
return set.keys();
}
@SuppressWarnings({"deprecation"})
public void save(OutputStream out, String comment) {
try {
store(out, comment);
} catch (IOException e) {
}
}
public synchronized void store(OutputStream out, String headComment) throws IOException {
OutputStreamWriter writer = new OutputStreamWriter(out, "ISO8859_1");
if (headComment != null) {
writer.write(indent);
writer.write("#");
writer.write(commentIndent);
writer.write(headComment);
writer.write(lineSeparator);
}
boolean firstProperty = true;
StringBuilder buffer = new StringBuilder(200);
for (Map.Entry<Object, Object> entry : entrySet()) {
String key = (String) entry.getKey();
String value = (String) entry.getValue();
if (!firstProperty && spaceBetweenProperties) {
buffer.append(lineSeparator);
}
String comment = comments.get(key);
Map<String, String> attributes = this.attributes.get(key);
if (comment != null || !attributes.isEmpty()) {
dumpComment(buffer, comment, attributes, "#");
if (spaceAfterComment) {
buffer.append(lineSeparator);
}
}
// ${indent}${key}=${value}
buffer.append(indent);
dumpString(buffer, key, true);
if (value != null && value.length() > 0) {
buffer.append(keyValueSeparator);
dumpString(buffer, value, false);
}
buffer.append(lineSeparator);
writer.write(buffer.toString());
buffer.setLength(0);
firstProperty = false;
}
writer.flush();
}
private void dumpString(StringBuilder buffer, String string, boolean key) {
int i = 0;
if (!key && i < string.length() && string.charAt(i) == ' ') {
buffer.append("\\ ");
i++;
}
for (; i < string.length(); i++) {
char ch = string.charAt(i);
switch (ch) {
case '\t':
buffer.append("\\t");
break;
case '\n':
buffer.append("\\n");
break;
case '\f':
buffer.append("\\f");
break;
case '\r':
buffer.append("\\r");
break;
default:
if ("\\".indexOf(ch) >= 0 || (key && "#!=: ".indexOf(ch) >= 0))
{
buffer.append('\\');
}
if (ch >= ' ' && ch <= '~') {
buffer.append(ch);
} else {
String hex = Integer.toHexString(ch);
buffer.append("\\u");
for (int j = 0; j < 4 - hex.length(); j++) {
buffer.append("0");
}
buffer.append(hex);
}
}
}
}
private void dumpComment(StringBuilder buffer, String comment, Map<String, String> attributes, String commentToken) {
if (comment != null) {
boolean startOfLine = true;
char ch = 0;
for (int i = 0; i < comment.length(); i++) {
ch = comment.charAt(i);
if (startOfLine) {
buffer.append(indent);
buffer.append(commentToken);
buffer.append(commentIndent);
startOfLine = false;
}
switch (ch) {
case '\r':
// if next character is not \n, this is the line break
if (i+1 < comment.length() && comment.charAt(i+1) != '\n') {
buffer.append(lineSeparator);
startOfLine = true;
}
break;
case '\n':
buffer.append(lineSeparator);
startOfLine = true;
break;
default:
buffer.append(ch);
}
}
// if the last character written was not a line break, write one now
if (ch != '\r' && ch != '\n'){
buffer.append(lineSeparator);
}
}
// ${indent}#${commentIndent}@${attributeName}=${attributeValue}
for (Map.Entry<String, String> entry : attributes.entrySet()) {
buffer.append(indent);
buffer.append("#");
buffer.append(commentIndent);
buffer.append("@");
buffer.append(entry.getKey());
if (entry.getValue() != null && entry.getValue().length() > 0) {
buffer.append("=");
buffer.append(entry.getValue());
}
buffer.append(lineSeparator);
}
}
public synchronized void loadFromXML(InputStream in) throws IOException {
if (in == null) {
throw new NullPointerException();
}
DocumentBuilder builder = getDocumentBuilder();
try {
Document doc = builder.parse(in);
NodeList entries = doc.getElementsByTagName("entry");
if (entries == null) {
return;
}
int entriesListLength = entries.getLength();
for (int i = 0; i < entriesListLength; i++) {
Element entry = (Element) entries.item(i);
String key = entry.getAttribute("key");
String value = entry.getTextContent();
put(key, value);
// search backwards for a comment
for (Node node = entry.getPreviousSibling(); node != null && !(node instanceof Element); node = node.getPreviousSibling()) {
if (node instanceof Comment) {
InputStream cin = new ByteArrayInputStream(((Comment) node).getData().getBytes());
// read comment line by line
StringBuilder comment = new StringBuilder();
LinkedHashMap<String,String> attributes = new LinkedHashMap<String,String>();
int nextByte;
char nextChar;
boolean firstLine = true;
int commentIndent = Integer.MAX_VALUE;
do {
// read one line
StringBuilder commentLine = new StringBuilder();
int commentLineIndent = 0;
boolean inIndent = true;
while (true) {
nextByte = cin.read();
if (nextByte < 0) break;
nextChar = (char) nextByte; // & 0xff
if (inIndent && nextChar == ' ') {
commentLineIndent++;
commentLine.append(' ');
} else if (inIndent && nextChar == '\t') {
commentLineIndent += 4;
commentLine.append(" ");
} else if (nextChar == '\r' || nextChar == '\n') {
break;
} else {
inIndent = false;
commentLine.append(nextChar);
}
}
// Determine indent
if (!firstLine && commentIndent == Integer.MAX_VALUE && commentLine.length() > 0) {
// if this is a new comment block, the comment indent size for this
// block is based the first full line of the comment (ignoring the
// line with the <!--
commentIndent = commentLineIndent;
}
commentLineIndent = Math.min(commentIndent, commentLineIndent);
if (commentLine.toString().trim().startsWith("@")) {
// process property attribute
String attribute = commentLine.toString().trim().substring(1);
String[] parts = attribute.split("=", 2);
String attributeName = parts[0].trim();
String attributeValue = parts.length == 2 ? parts[1].trim() : "";
attributes.put(attributeName, attributeValue);
} else {
// append comment
if (comment.length() != 0) {
comment.append(lineSeparator);
}
comment.append(commentLine.toString().substring(commentLineIndent));
}
firstLine = false;
} while (nextByte > 0);
if (comment.length() > 0) {
setComment(key, comment.toString());
}
this.attributes.put(normalize(key), attributes);
break;
}
}
}
} catch (SAXException e) {
throw new InvalidPropertiesFormatException(e);
}
}
private DocumentBuilder getDocumentBuilder() {
if (builder == null) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
try {
builder = factory.newDocumentBuilder();
} catch (ParserConfigurationException e) {
throw new Error(e);
}
builder.setErrorHandler(new ErrorHandler() {
public void warning(SAXParseException e) throws SAXException {
throw e;
}
public void error(SAXParseException e) throws SAXException {
throw e;
}
public void fatalError(SAXParseException e) throws SAXException {
throw e;
}
});
builder.setEntityResolver(new EntityResolver() {
public InputSource resolveEntity(String publicId,
String systemId) throws SAXException, IOException {
if (systemId.equals(PROP_DTD_NAME)) {
InputSource result = new InputSource(new StringReader(PROP_DTD));
result.setSystemId(PROP_DTD_NAME);
return result;
}
throw new SAXException("Invalid DOCTYPE declaration: " + systemId);
}
});
}
return builder;
}
public void storeToXML(OutputStream os, String comment) throws IOException {
storeToXML(os, comment, "UTF-8");
}
public synchronized void storeToXML(OutputStream os, String headComment, String encoding) throws IOException {
if (os == null || encoding == null) {
throw new NullPointerException();
}
// for somereason utf-8 is always used
String encodingCanonicalName = "UTF-8";
// header
OutputStreamWriter osw = new OutputStreamWriter(os, encodingCanonicalName);
StringBuilder buf = new StringBuilder(200);
buf.append("<?xml version=\"1.0\" encoding=\"").append(encodingCanonicalName).append("\"?>").append(lineSeparator);
buf.append("<!DOCTYPE properties SYSTEM \"" + PROP_DTD_NAME + "\">").append(lineSeparator);
buf.append("<properties>").append(lineSeparator);
// comment
if (headComment != null) {
buf.append(indent);
buf.append("<comment>");
buf.append(substitutePredefinedEntries(headComment));
buf.append("</comment>");
buf.append(lineSeparator);
if (!isEmpty() && (spaceBetweenProperties || spaceAfterComment)) {
buf.append(lineSeparator);
}
}
// properties
boolean firstProperty = true;
for (Map.Entry<Object, Object> entry : entrySet()) {
String key = (String) entry.getKey();
String value = (String) entry.getValue();
if (!firstProperty && spaceBetweenProperties) {
buf.append(lineSeparator);
}
// property comment
String comment = comments.get(key);
Map<String, String> attributes = this.attributes.get(key);
if (comment != null || !attributes.isEmpty()) {
buf.append(indent);
buf.append("<!--");
buf.append(lineSeparator);
// comments can't contain "--" so we shrink all sequences of them to a single "-"
comment = comment.replaceAll("--*", "-");
dumpComment(buf, comment, attributes, "");
buf.append(indent);
buf.append("-->");
buf.append(lineSeparator);
if (spaceAfterComment) {
buf.append(lineSeparator);
}
}
// property
buf.append(indent);
buf.append("<entry key=\"");
buf.append(substitutePredefinedEntries(key));
buf.append("\">");
buf.append(substitutePredefinedEntries(value));
buf.append("</entry>");
buf.append(lineSeparator);
firstProperty = false;
}
buf.append("</properties>").append(lineSeparator);
osw.write(buf.toString());
osw.flush();
}
private String substitutePredefinedEntries(String s) {
/*
* substitution for predefined character entities
* to use them safely in XML
*/
return s.replaceAll("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll("\u0027", "'")
.replaceAll("\"", """);
}
//
// Delegate all remaining methods to the properties object
//
public boolean isEmpty() {
return properties.isEmpty();
}
public int size() {
return properties.size();
}
public Object get(Object key) {
key = normalize(key);
return properties.get(key);
}
public Object put(Object key, Object value) {
key = normalize(key);
if (key instanceof String) {
String name = (String) key;
if (!attributes.containsKey(name)) {
attributes.put(name, new LinkedHashMap<String,String>());
}
}
return properties.put(key, value);
}
public Object remove(Object key) {
key = normalize(key);
comments.remove(key);
attributes.remove(key);
return properties.remove(key);
}
public void putAll(Map<?, ?> t) {
for (Map.Entry<?, ?> entry : t.entrySet()) {
put(entry.getKey(), entry.getValue());
}
if (t instanceof SuperProperties) {
SuperProperties superProperties = (SuperProperties) t;
for (Map.Entry<String, String> entry : superProperties.comments.entrySet()) {
comments.put(normalize(entry.getKey()), entry.getValue());
}
for (Map.Entry<String, LinkedHashMap<String, String>> entry : superProperties.attributes.entrySet()) {
attributes.put(normalize(entry.getKey()), entry.getValue());
}
}
}
/**
* Returns an unmodifiable view of the keys.
* @return an unmodifiable view of the keys
*/
public Set<Object> keySet() {
return Collections.unmodifiableSet(properties.keySet());
}
public Enumeration<Object> keys() {
return Collections.enumeration(properties.keySet());
}
/**
* Returns an unmodifiable view of the values.
* @return an unmodifiable view of the values
*/
public Collection<Object> values() {
return Collections.unmodifiableCollection(properties.values());
}
/**
* Returns an unmodifiable view of the entries.
* @return an unmodifiable view of the entries
*/
public Set<Map.Entry<Object, Object>> entrySet() {
return Collections.unmodifiableSet(properties.entrySet());
}
public Enumeration<Object> elements() {
return Collections.enumeration(properties.values());
}
public boolean containsKey(Object key) {
key = normalize(key);
return properties.containsKey(key);
}
public boolean containsValue(Object value) {
return properties.containsValue(value);
}
public boolean contains(Object value) {
return properties.containsValue(value);
}
public void clear() {
properties.clear();
comments.clear();
attributes.clear();
}
@SuppressWarnings({"unchecked"})
public Object clone() {
SuperProperties clone = (SuperProperties) super.clone();
clone.properties = (LinkedHashMap<Object,Object>) properties.clone();
clone.comments = (LinkedHashMap<String,String>) comments.clone();
clone.attributes = (LinkedHashMap<String,LinkedHashMap<String,String>>) attributes.clone();
for (Map.Entry<String, LinkedHashMap<String, String>> entry : clone.attributes.entrySet()) {
entry.setValue((LinkedHashMap<String, String>) entry.getValue().clone());
}
return clone;
}
@SuppressWarnings({"EqualsWhichDoesntCheckParameterClass"})
public boolean equals(Object o) {
return properties.equals(o);
}
public int hashCode() {
return properties.hashCode();
}
public String toString() {
return properties.toString();
}
protected void rehash() {
}
private Object normalize(Object key){
if (key instanceof String) {
return normalize((String)key);
}
return key;
}
private String normalize(String property){
if (!caseInsensitive) {
return property;
}
if (super.containsKey(property)){
return property;
}
for (Object o : keySet()) {
if (o instanceof String) {
String key = (String) o;
if (key.equalsIgnoreCase(property)) return key;
}
}
if (defaults != null) {
for (Object o : defaults.keySet()) {
if (o instanceof String) {
String key = (String) o;
if (key.equalsIgnoreCase(property)) return key;
}
}
}
return property;
}
}