package com.randomnoun.common;
   
   /* (c) 2013 randomnoun. All Rights Reserved. This work is licensed under a
    * BSD Simplified License. (http://www.randomnoun.com/bsd-simplified.html)
    */
   import java.io.FileReader;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.InputStreamReader;
  import java.io.LineNumberReader;
  import java.io.OutputStream;
  import java.io.PrintStream;
  import java.io.PrintWriter;
  import java.io.Reader;
  import java.io.Writer;
  import java.nio.charset.Charset;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.InvalidPropertiesFormatException;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Properties;
  import java.util.Set;
  import java.util.StringTokenizer;
  import java.util.function.BiConsumer;
  import java.util.function.BiFunction;
  import java.util.function.Function;
  
  import org.apache.log4j.Logger;
  
  /**
   * The PropertyParser class parses a property definition text file into
   * a Properties object.
   *
   * <p>This parser differs from the standard Properties parser in that
   * sections can be marked off for particular regions (e.g. properties
   * that only take effect in development, or when run on certain machines).
   * The current region
   * is specified by the <code>com.randomnoun.common.mode</code> system property
   * set on the VM commandline. If this system property is not set,
   * the region defaults to the value "<code>localhost-dev-unknown</code>".
   * An alternate constructor exists if you
   * wish to specify the region manually.
   *
   * <p>Environments are specified in '<i>machine-release-subsystem</i>'
   * format, with each segment set as follows:
   * <ul>
   * <li>machine - the hostname of the system (in lowercase)
   * <li>release - the development phase of the system (either set to <code>dev</code>,
   *   <code>xpt</code>, <code>prd</code> for development, acceptance or production
   * <li>subsystem - the subsystem that this VM represents. 
   * </ul>
   *
   * <p>Properties are specified in the standard "propertyName=propertyValue" method.
   * Whitespace is removed from either side of the '=' character. New-lines
   * can be specified in the property value by using the escape sequence '\n'.
   * Lines can be continued over a single line by placing the character '\' at
   * at the end of the line to be continued; e.g.
   *
   * <pre style="code">
   *   property1=value1
   *   property2=this is a very long value for property2, which spans \
   *             over a single line.
   * </pre>
   *
   * <p>Properties that are specific to a particular region should be surrounded
   * by the lines "STARTENVIRONMENT environmentMask" and "ENDENVIRONMENT environmentMask".
   * Individual properties can be defined for a region by prefixing the line
   * with "ENV environmentMask"; e.g.
   *
   * <pre style="code">
   *   property1=all regions
   *
   *   STARTENVIRONMENT *-xpt-*
   *     property2=this property only set in acceptance region
   *     property3=same for this property
   *   ENDENVIRONMENT
   *
   *   STARTENVIRONMENT dtp11523-dev-*
   *     property2=these properties only set in the development region
   *     property3=running on the host dtp11523
   *   ENDENVIRONMENT
   *
   *   ENV *-prd-* property4=this property only visible in production
   * </pre>
   *
   * <p>As shown above, the '<code>*</code>' character can be used to specify a property
   * across multiple regions. The keywords 'STARTENVIRONMENT', 'ENDENVIRONMENT' and
   * 'ENV' are case-insensitive
   * 
   * <p>You can now also specify environments based on the values of previously-defined
   * properties; this allows a simple <code>#ifdef</code> style facility. There are 
   * two types of syntax, which use regex matching or simple string matching; e.g.
   * 
   * <pre style="code">
  *   enable.fileAct=true
  *   compound.property=123-456-789
  * 
  *   STARTENVIRONMENT enable.fileAct = true
  *     # these properties are only set when enable.fileAct is set to true
  *   ENDENVIRONMENT
  *   STARTENVIRONMENT compound.property =~ *-789
  *     # these properties are only set when compound.property ends with -789
  *   ENDENVIRONMENT
  * </pre>
  * 
  * <p>Property files can contain any number of blank lines, or comments (lines
  * starting with the '#' character), which will be ignored by the parser.
  *
  * <p>Any occurences of the string "<code>\n</code>" in a property value will be
  * replaced by a newline character.
  *
  * <p>A property make also contain a List, rather than a string, by including the
  * index of the list item in square brackets in the property key; e.g.
  *
  * <pre style="code">
  *   listname[1]=first element
  *   listname[3]=third element
  * </pre>
  *
  * <p>This implementation returns an ArrayList of Strings for these types of declarations.
  * Undeclared array elements that appear before the last index will return null.
  *
  * <p>If you want to create a list, but the index of the elements is unknown (they are 
  * dependant on other properties, for example), then you can use a "*" to denote the
  * next available list index, or leave it empty to denote the last used list index; e.g.
  * 
  * <pre style="code">
  * testList[0].a=a-value 0
  * testList[0].b=b-value 0
  * testList[0].c=a-value 0
  *  
  * testList[1].a=a-value 1
  * testList[1].b=b-value 1
  * testList[1].c=a-value 1
  *  
  * testList[*].a=a-value 2
  * testList[].b=b-value 2
  * testList[].c=a-value 2
  * </pre>
  * 
  * will generate a three-element list, each of which contains a map with three key/value pairs.
  *
  * <p>Properties that appear multiple times will take the value of the last-specified
  * value.
  *
  *
  * @author  knoxg
  * 
  */
 public class PropertyParser {
 
     /** Logger instance for this class */
     public static final Logger logger = Logger.getLogger(PropertyParser.class.getName());
 
     /** display each token as it is read */
     static private final boolean verbose = false;
 
     /** file to parse */
     private LineNumberReader lineReader;
 
     /** line to parse */
     private StringTokenizer thisline;
 
     /** environment processing enabled */
     private boolean inEnvironment = false;
 
     /** currently within correct environment */
     private boolean correctEnvironment = true;
 
     /** comment parsed so far */
     private String comment = null;
 
     /** current environment string */
     private String environmentID = "";
 
     /** the properties object we will populate from this InputStream */
     private Properties properties = null;
     
     private Properties propertyComments = null; 
 
     public static class PropertiesWithComments extends Properties {
     	/** Generated serialVersionUID */
 		private static final long serialVersionUID = -780503047200669250L;
 		Properties p;
     	Properties c;
 
     	public PropertiesWithComments(Properties p, Properties c) {
     		this.p = p;
     		this.c = c;
     	}
     	
 		public String getComment(String key) {
 			return c.getProperty(key);
 		}
 		
 		public Properties getComments() {
 			return c;
 		}
 
     	
 		public Object setProperty(String key, String value) {
 			return p.setProperty(key, value);
 		}
 
 		public void load(Reader reader) throws IOException {
 			p.load(reader);
 		}
 
 		public void load(InputStream inStream) throws IOException {
 			p.load(inStream);
 		}
 
 		/** @deprecated */
 		public void save(OutputStream out, String comments) {
 			p.save(out, comments);
 		}
 
 		public void store(Writer writer, String comments) throws IOException {
 			p.store(writer, comments);
 		}
 
 		public void store(OutputStream out, String comments) throws IOException {
 			p.store(out, comments);
 		}
 
 		public void loadFromXML(InputStream in) throws IOException, InvalidPropertiesFormatException {
 			p.loadFromXML(in);
 		}
 
 		public void storeToXML(OutputStream os, String comment) throws IOException {
 			p.storeToXML(os, comment);
 		}
 
 		public void storeToXML(OutputStream os, String comment, String encoding) throws IOException {
 			p.storeToXML(os, comment, encoding);
 		}
 
 		public void storeToXML(OutputStream os, String comment, Charset charset) throws IOException {
 			p.storeToXML(os, comment, charset);
 		}
 
 		public String getProperty(String key) {
 			return p.getProperty(key);
 		}
 
 		public String getProperty(String key, String defaultValue) {
 			return p.getProperty(key, defaultValue);
 		}
 
 		public Enumeration<?> propertyNames() {
 			return p.propertyNames();
 		}
 
 		public Set<String> stringPropertyNames() {
 			return p.stringPropertyNames();
 		}
 
 		public void list(PrintStream out) {
 			p.list(out);
 		}
 
 		public void list(PrintWriter out) {
 			p.list(out);
 		}
 
 		public int size() {
 			return p.size();
 		}
 
 		public boolean isEmpty() {
 			return p.isEmpty();
 		}
 
 		public Enumeration<Object> keys() {
 			return p.keys();
 		}
 
 		public Enumeration<Object> elements() {
 			return p.elements();
 		}
 
 		public boolean contains(Object value) {
 			return p.contains(value);
 		}
 
 		public boolean containsValue(Object value) {
 			return p.containsValue(value);
 		}
 
 		public boolean containsKey(Object key) {
 			return p.containsKey(key);
 		}
 
 		public Object get(Object key) {
 			return p.get(key);
 		}
 
 		public Object put(Object key, Object value) {
 			return p.put(key, value);
 		}
 
 		public Object remove(Object key) {
 			return p.remove(key);
 		}
 
 		public void putAll(Map<?, ?> t) {
 			p.putAll(t);
 		}
 
 		public void clear() {
 			p.clear();
 		}
 
 		public String toString() {
 			return p.toString();
 		}
 
 		public Set<Object> keySet() {
 			return p.keySet();
 		}
 
 		public Collection<Object> values() {
 			return p.values();
 		}
 
 		public Set<java.util.Map.Entry<Object, Object>> entrySet() {
 			return p.entrySet();
 		}
 
 		public boolean equals(Object o) {
 			return p.equals(o);
 		}
 
 		public int hashCode() {
 			return p.hashCode();
 		}
 
 		public Object getOrDefault(Object key, Object defaultValue) {
 			return p.getOrDefault(key, defaultValue);
 		}
 
 		public void forEach(BiConsumer<? super Object, ? super Object> action) {
 			p.forEach(action);
 		}
 
 		public void replaceAll(BiFunction<? super Object, ? super Object, ?> function) {
 			p.replaceAll(function);
 		}
 
 		public Object putIfAbsent(Object key, Object value) {
 			return p.putIfAbsent(key, value);
 		}
 
 		public boolean remove(Object key, Object value) {
 			return p.remove(key, value);
 		}
 
 		public boolean replace(Object key, Object oldValue, Object newValue) {
 			return p.replace(key, oldValue, newValue);
 		}
 
 		public Object replace(Object key, Object value) {
 			return p.replace(key, value);
 		}
 
 		public Object computeIfAbsent(Object key, Function<? super Object, ?> mappingFunction) {
 			return p.computeIfAbsent(key, mappingFunction);
 		}
 
 		public Object computeIfPresent(Object key, BiFunction<? super Object, ? super Object, ?> remappingFunction) {
 			return p.computeIfPresent(key, remappingFunction);
 		}
 
 		public Object compute(Object key, BiFunction<? super Object, ? super Object, ?> remappingFunction) {
 			return p.compute(key, remappingFunction);
 		}
 
 		public Object merge(Object key, Object value, BiFunction<? super Object, ? super Object, ?> remappingFunction) {
 			return p.merge(key, value, remappingFunction);
 		}
 
 		public Object clone() {
 			return p.clone();
 		}
     	
     }
     
     /**
      * Create a new Parser object. Note that parsing does not begin until the
      * Parse method is called on this object.
      *
      * @param reader        The source of the site definition text.
      * @param environmentID     The environment ID in which to parse this text.
      */
     public PropertyParser(Reader reader, String environmentID) {
         lineReader = new LineNumberReader(reader);
         this.environmentID = environmentID;
     }
 
     /**
      * Create a new Parser object. Note that parsing does not begin until the
      * Parse method is called on this object. Assumes a DEV environment
      *
      * @param reader The source of the site definition text.
      */
     public PropertyParser(Reader reader) {
         this(reader, System.getProperty("com.randomnoun.common.mode", "localhost-dev-unknown"));
     }
 
     /**
      * Generates a Properties object from the input stream.
      *
      * @return A valid Properties object.
      *
      * @throws IOException
      * @throws ParseException
      */
     public PropertiesWithComments parse()
         throws ParseException, IOException {
         String line = ""; // current line
         String token = ""; // current token
 
         // ensure that all class fields have been reset
         properties = new Properties();
         propertyComments = new Properties();
         PropertiesWithComments pwc = new PropertiesWithComments(properties, propertyComments);
         
 
         line = lineReader.readLine();
 
         while (line != null) {
             line = line.trim();
 
             // line-continuation (a line ending with '\' is appended with the next)
             // could prove hazardous if we get a \ on the last line
             while (line != null && line.endsWith("\\")) {
                 line = line.substring(0, line.length() - 1);
 
                 try {
                     line = line + lineReader.readLine().trim();
                 } catch (NullPointerException npe) {
                     // end of file reached; ignore
                 }
             }
 
             // true = don't return delimiters
             thisline = new StringTokenizer(line, " =\t\n\r", true);
 
             if (thisline.hasMoreTokens()) {
                 token = parseToken("keyword");
 
                 // are we in the correct environment ?
                 if (correctEnvironment || token.toLowerCase().equals("endenvironment")) {
                     parseLine(token);
                 }
             }
 
             line = lineReader.readLine();
         }
 
         return pwc;
     }
 
     /**
      * Parses a single line of the site definition file.
      *
      * @param token The token that was at the beginning of this line
      *
      * @throws ParseException
      */
     @SuppressWarnings("unchecked")
 	private void parseLine(String token)
         throws ParseException {
         String lowerCaseToken;
         String nextToken = null;
         String value = null;
         // String comment = null;
 
         // System.out.println("P " + token + "(" + line + ")");
         lowerCaseToken = token.toLowerCase();
 
         if (token.startsWith("##")) {
         	comment = (comment == null ? "" : comment + "\n" ) + parseTokenToEOL("property value");
         } else if (token.startsWith("#")) {
         	comment = (comment == null ? null : comment + "\n" + parseTokenToEOL("property value"));
         } else if (lowerCaseToken.equals("startenvironment")) {
             parseStartEnvironment();
         } else if (lowerCaseToken.equals("endenvironment")) {
             parseEndEnvironment();
         } else if (lowerCaseToken.equals("env")) {
             parseEnv();
 		} else if (lowerCaseToken.equals("includeresource")) {
 			parseIncludeResource();
         } else {
             // see if this is a key=value property assignment
             try {
                 nextToken = parseToken("token");
             } catch (ParseException pe) {
                 newParseException("Unknown keyword '" + token + "', '=' expected");
             }
 
             if (nextToken.equals("=")) {
                 // must be in a key=value assignment
                 value = null;
 
                 try {
                     value = parseTokenToEOL("property value");
                 } catch (ParseException pe) {
                 }
 
                 if (value == null) {
                     value = "";
                 }
 
                 // check if this is an array element	
                 int lb = token.indexOf('[');
                 int rb = token.indexOf(']');
                 
 
                 if (lb != -1 || rb != -1) {
                     if (lb == -1 || rb == -1) {
                         newParseException("Invalid list property key '" + token + "'");
                     }
                     List<Object> list = null;
                     String keyPart = token.substring(0, lb);
                     String listPart = token.substring(lb);
                     try {
                         list = (List<Object>) properties.get(keyPart);
                     } catch (ClassCastException cce) {
                         newParseException("Cannot create list '" + token + "', this property already exists");
                     }
                     if (list == null) {
                         list = new ArrayList<Object>();
                         properties.put(keyPart, list);
                     }
                     // if list index is "*" then create a new list index; if it's "-", then use the last index
                     String index = token.substring(lb+1, rb);
                     if (index.equals("*")) {
                     	index = String.valueOf(list.size()); // 0-based list, so next index is set to the size
                     	listPart = "[" + index + "]" + listPart.substring(listPart.indexOf("]")+1);
                     } else if (index.equals("")) {
                     	index = String.valueOf(list.size()-1);
 						listPart = "[" + index + "]" + listPart.substring(listPart.indexOf("]")+1);
                     }
                     
                     Struct.setValue(list, listPart, value, true, true, true);
                     // don't store comments in lists
                     comment = null;
                 } else {
                     // no index supplied, just set the property	
                     properties.setProperty(token, value);
                     if (comment != null) {
                     	propertyComments.setProperty(token, comment);
                     	comment = null;
                     }
                 }
             } else {
                 newParseException("Unknown token '" + nextToken + "', '=' expected");
             }
         }
     }
 
     /**
      * Creates and throws a new parse exception, which includes the current parse
      * position within the Reader.
      *
      * @param s The additional text to be included in this exception
      *
      * @throws ParseException The parse exception requested
      */
     private void newParseException(String s)
         throws ParseException {
         throw new ParseException("line " + lineReader.getLineNumber() + ": " + s, 0);
     }
 
     /**
      * Returns the next token.
      *
      * @param what The type of token we are expecting. This string is only used
      *   in any parseExceptions which are thrown.
      *
      * @return The next token on the line.
      *
      * @throws ParseException A parsing exception has occurred.
      */
     private String parseToken(String what)
         throws ParseException {
         String result = null;
 
         // keep grabbing tokens, until we hit something that isn't considered whitespace
         while (result == null || result.equals(" ") || result.equals("\r") || result.equals("\n") || result.equals("\t")) {
             if (!thisline.hasMoreTokens()) {
                 newParseException("Expecting " + what);
             }
 
             result = thisline.nextToken(" =\t\n\r");
         }
 
         // convert \n's to newlines.
         result = result.replaceAll("\\\\n", "\n");
 
         if (verbose) {
             logger.debug("parsed token: '" + result + "'");
         }
 
         return result;
     }
 
     /**
      * Grabs every token until the end of line, and returns it as a string. If the
      * debugging variable 'verbose' is set to true, then each token is sent
      * to System.out as it is read. Enclosing single or double-quotes are removed.
      *
      * @param what The type of token we are expecting. This text is used
      *   in any parseExceptions which are thrown.
      *
      * @return The remaining text.
      *
      * @throws ParseException
      */
     private String parseTokenToEOL(String what)
         throws ParseException {
         String token;
 
         if (!thisline.hasMoreTokens()) {
             newParseException("Expecting " + what);
         }
 
         token = thisline.nextToken("\n").trim();
         token = token.replaceAll("\\\\n", "\n");
 
         if (verbose) {
             System.out.println("parsed token: " + token);
         }
 
         return token;
     }
 
     /**
      * Processes an ENV rule
      *
      * @throws ParseException
      */
     private void parseEnv()
         throws ParseException {
         String selectedenvironmentID;
         String token;
 
         selectedenvironmentID = parseToken("Environment ID");
 
         // @TODO this should really use the same rules as parseStartEnvironment
         if (selectedenvironmentID.equals(environmentID)) {
             token = parseToken("keyword").toLowerCase();
             parseLine(token);
         }
     }
 
 	private void parseIncludeResource() throws ParseException {
 		// include another properties file in here. This has a very
 		// good chance of creating a infinite loop if one property file
 		// includes another one, which in turn includes the first one. 
 		// - this will manifest itself in some kind of OutOfMemoryException
 		// or a StackOverflowException
 		
 		String resourceName = parseTokenToEOL("resource name");
 		logger.debug("Including property resource '" + resourceName + "'");
 
 		// load properties from classpath (in .EAR)
 		InputStream inputStream = PropertyParser.class.getClassLoader().getResourceAsStream(resourceName);
 		if (inputStream==null) {
 			throw new ParseException("Could not find included resource '" + resourceName + "'", 0);
 		}
 		PropertyParser propertyParser = new PropertyParser(new InputStreamReader(inputStream), environmentID);
 		Properties includedProperties = new Properties();
 		try {
 			includedProperties = propertyParser.parse();
 		} catch (Exception e) {
 			throw (ParseException) new ParseException("Could not load included resource '" +
 				resourceName + "'", 0).initCause(e);
 		}
 		
 		// should merge lists/maps, rather than replacing them.
 		// (maybe this should be configurable ?)
 		// @TODO code below only merges lists
 		for (Iterator<Entry<Object, Object>> i = includedProperties.entrySet().iterator(); i.hasNext(); ) {
 			Map.Entry<Object, Object> entry = i.next();
 			if (entry.getValue() instanceof List) {
 				Object existingObj = properties.get(entry.getKey());
 				if (existingObj==null || !(existingObj instanceof List)) {
 					properties.put(entry.getKey(), entry.getValue());
 				} else {
 					@SuppressWarnings("unchecked")
 					List<Object> existingList = (List<Object>) existingObj;
 					@SuppressWarnings("unchecked")
 					List<Object> listValue = (List<Object>) entry.getValue();
 					for (int j=0; j<listValue.size(); j++) {
 						if (listValue.get(j)!=null) {
 							Struct.setListElement(existingList, j, listValue.get(j));
 						}
 					}
 				}
 			} else {
 				properties.put(entry.getKey(), entry.getValue());
 			}
 		}
 		// properties.putAll(includedProperties);
 	}
 
     /** Begins per-environment parsing rules.
      *  @throws ParseException
      */
     private void parseStartEnvironment()
         throws ParseException {
         if (inEnvironment) {
             newParseException("attempted to nest environment areas");
         }
         String propertyName = "environmentId";
         String propertyMatch = null;
         String propertyValue = null;
         String envSpec = parseTokenToEOL("Environment specification");
         if (envSpec.indexOf("=~")!=-1) {
         	propertyName = envSpec.substring(0, envSpec.indexOf("=~")).trim();
         	propertyMatch = envSpec.substring(envSpec.indexOf("=~")+2).trim();
 			propertyMatch = propertyMatch.replaceAll("\\*", ".*");
         	propertyValue = propertyName.equals("environmentId") ? environmentID : properties.getProperty(propertyName);
         	if (propertyValue==null) { propertyValue = ""; }
 			correctEnvironment = propertyValue.matches(propertyMatch);	
         } else if (envSpec.indexOf("=")!=-1) {
 			propertyName = envSpec.substring(0, envSpec.indexOf("=")).trim();
 			propertyMatch = envSpec.substring(envSpec.indexOf("=")+1).trim();
 			propertyValue = propertyName.equals("environmentId") ? environmentID : properties.getProperty(propertyName);
 			if (propertyValue==null) { propertyValue = ""; }
 			correctEnvironment = propertyValue.equals(propertyMatch);	
         } else {
         	// not on 'xxx=xxx' form, default to old behaviour (match on envId)
 			propertyMatch = envSpec.replaceAll("\\*", ".*");
 			correctEnvironment = environmentID.toLowerCase().matches(propertyMatch.toLowerCase());
         }
         
         // test for "property=value" style environments
         //selectedenvironmentID = selectedenvironmentID.replaceAll("\\*", ".*");
         //correctEnvironment = environmentID.matches(selectedenvironmentID);
         inEnvironment = true;
     }
 
     /**
      * Completes per-environment parsing rules.
      *
      * @throws ParseException
      */
     private void parseEndEnvironment()
         throws ParseException {
         if (!inEnvironment) {
             newParseException("'endenvironment' without matching 'startenvironment'");
         }
 
         inEnvironment = false;
         correctEnvironment = true;
     }
 
     /**
      * Returns a subset of a Properties object. The subset is determined by only
      * returning those key/value pairs whose keys begin with a set prefix. e.g.
      * if 'a' contains the properties
      *
      * <pre>
      *   customer.1.name=fish
      *   customer.1.description=Patagonian toothfish
      *   customer.2.name=hunter
      *   customer.2.description=Patagonian toothfish hunter
      *   customer.11.name=spear
      *   customer.11.description=Patagonian toothfish hunter's spear
      * </pre>
      *
      * <p>then calling <code>restrict(a, "customer.1", false)</code> will return:
      *
      * <pre>
      *   customer.1.name=fish
      *   customer.1.description=Patagonian toothfish
      * </pre>
      *
      * <p>setting the 'removePrefix' to true will remove the initial prefix from
      * the returned property list; <code>restrict(a, "customer.1", true)</code> in
      * this case will then return:
      *
      * <pre>
      *   name=fish
      *   description=Patagonian toothfish
      * </pre>
      *
      * <p>Note that the prefix passed in to this method has no trailing period,
      * but each property must contain that period (to prevent <code>customer.11</code>
      * from being returned in the example above).
      *
      * <p>If 'properties' is set to null, then this method will return null.
      * If 'prefix' is set to null, then this method will return the entire property list.
      *
      * @param properties The initial property list that we wish to restrict
      * @param prefix     The prefix used to restrict the property list
      * @param removePrefix  If set to true, the result keys will be stripped of the initial prefix text
      *
      * @return A restricted property list.
      */
     public static Map<? extends Object, ? extends Object> restrict(Map<Object, Object> properties, String prefix, boolean removePrefix) {
         if (properties == null) {
             return null;
         }
 
         if (prefix == null) {
             return properties;
         }
 
         Properties result = new Properties();
 
         // this could possibly break existing, yet weird code
         // if (!prefix.endsWith(".")) { prefix = prefix + "."; };
         prefix = prefix + ".";
         
         Map.Entry<Object, Object> entry;
 
         for (Iterator<Entry<Object, Object>> i = properties.entrySet().iterator(); i.hasNext();) {
             entry = i.next();
 
             String key = (String) entry.getKey();
 
             if (key.startsWith(prefix)) {
                 if (removePrefix) {
                     key = key.substring(prefix.length());
                 }
 
                 result.put(key, entry.getValue());
             }
         }
 
         return result;
     }
 
     /**
      * Method used to test the parser from the command line. The file to parse is
      * specified on the command line; if missing, then it uses 'test.properties'
      * as the default.
      *
      * @param args
      *
      * @throws IOException
      * @throws ParseException
      */
     public static void main(String[] args)
         throws IOException, ParseException {
         String filename = "test.properties";
         PropertyParser propertyParser;
 
         if (args.length != 1) {
             System.out.println("Reading from '" + filename + "' by default...");
         } else {
             filename = args[0];
         }
 
         try {
             propertyParser = new PropertyParser(new FileReader(filename));
             propertyParser.parse();
             System.out.println("Parse OK");
         } catch (ParseException pe) {
             System.out.println("Caught ParseException: " + pe);
             pe.printStackTrace();
         }
     }
 }