Coverage Report

Coverage Report - org.crosswire.common.util.PropertyMap

Classes in this File

0/22

0/12

 /**
  * Distribution License:
  * JSword is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License, version 2.1 or later
  * as published by the Free Software Foundation. This program is distributed
  * in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * The License is available on the internet at:
  *      http://www.gnu.org/copyleft/lgpl.html
  * or by writing to:
  *      Free Software Foundation, Inc.
  *      59 Temple Place - Suite 330
  *      Boston, MA 02111-1307, USA
  *
  * © CrossWire Bible Society, 2008 - 2016
  *
  */
 package org.crosswire.common.util;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Enumeration;
 import java.util.LinkedHashMap;
 import java.util.Properties;
 
 
 /**
  * A PropertyMap is a Map&lt;String,String&gt; sitting over top a Property file.
  * As such it must be defined in the same way as a java.util.Properties expects.
  *
  * @see java.util.Properties
  * @see gnu.lgpl.License The GNU Lesser General Public License for details.
  * @author DM Smith
  */
 public class PropertyMap extends LinkedHashMap<String, String> {
     /**
      * Creates an empty property list with no default values.
      */
     public PropertyMap() {
         this(null);
     }
 
     /**
      * Creates an empty property map with the specified defaults.
      *
      * @param   defaults   the defaults.
      */
     public PropertyMap(PropertyMap defaults) {
         this.defaults = defaults;
     }
 
     /**
      * Searches for the property with the specified key in this property list.
      * If the key is not found in this property list, the default property list,
      * and its defaults, recursively, are then checked. The method returns
      * <code>null</code> if the property is not found.
      *
      * @param   key   the lookup key.
      * @return  the value in this property list with the specified key value.
      * @see     java.util.Properties#setProperty
      */
     public String get(String key) {
         String value = super.get(key);
         return ((value == null) && (defaults != null)) ? defaults.get(key) : value;
     }
 
     /**
      * Searches for the property with the specified key in this property list.
      * If the key is not found in this property list, the default property list,
      * and its defaults, recursively, are then checked. The method returns the
      * default value argument if the property is not found.
      *
      * @param   key            the lookup key.
      * @param   defaultValue   a default value.
      *
      * @return  the value in this property list with the specified key value.
      * @see     java.util.Properties#setProperty
      */
     public String get(String key, String defaultValue) {
         String value = get(key);
         return value == null ? defaultValue : value;
     }
 
     /**
      * Reads a property list (key and element pairs) from the input
      * byte stream. The input stream is in a simple line-oriented
      * format as specified in
      * {@link java.util.Properties#load(java.io.InputStream) load(InputStream)} and is assumed to use
      * the ISO 8859-1 character encoding; that is each byte is one Latin1
      * character. Characters not in Latin1, and certain special characters,
      * are represented in keys and elements using
      * <a href="http://java.sun.com/docs/books/jls/third_edition/html/lexical.html#3.3">Unicode escapes</a>.
      * <p>
      * The specified stream remains open after this method returns.
      *
      * @param      inStream   the input stream.
      * @exception  IOException  if an error occurred when reading from the
      *             input stream.
      * @throws     IllegalArgumentException if the input stream contains a
      *         malformed Unicode escape sequence.
      * @since 1.2
      */
     public void load(InputStream inStream) throws IOException {
         Properties prop = new Properties();
         prop.load(inStream);
         for (Enumeration<Object> e = prop.keys(); e.hasMoreElements(); ) {
             Object k = e.nextElement();
             Object v = prop.get(k);
             if (k instanceof String && v instanceof String) {
                 put((String) k, (String) v);
             }
         }
     }
 
     /**
      * Writes this property list (key and element pairs) in this
      * <code>PropertyMap</code> table to the output stream in a format suitable
      * for loading into a <code>PropertyMap</code> table using the
      * {@link #load(InputStream) load(InputStream)} method.
      * <p>
      * Properties from the defaults table of this <code>PropertyMap</code>
      * table (if any) are <i>not</i> written out by this method.
      * <p>
      * This method outputs the comments, properties keys and values in 
      * the same format as specified in
      * {@link java.util.Properties#store(java.io.OutputStream, java.lang.String) store(Writer)},
      * <p>
      * After the entries have been written, the output stream is flushed.  
      * The output stream remains open after this method returns.
      * <p>
      * @param   out      an output stream.
      * @param   comments   a description of the property list.
      * @exception  IOException if writing this property list to the specified
      *             output stream throws an <tt>IOException</tt>.
      * @exception  NullPointerException  if <code>out</code> is null.
      * @since 1.2
      */
     public void store(OutputStream out, String comments) throws IOException {
         Properties temp = new Properties();
         temp.putAll(this);
         temp.store(out, comments);
     }
 
     /**
      * Default values for any keys not found in this property map.
      */
     private PropertyMap defaults;
 
     /**
      * Serialization ID
      */
     private static final long serialVersionUID = 2821277155924802795L;
 }

1		/**
2		* Distribution License:
3		* JSword is free software; you can redistribute it and/or modify it under
4		* the terms of the GNU Lesser General Public License, version 2.1 or later
5		* as published by the Free Software Foundation. This program is distributed
6		* in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
7		* the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
8		* See the GNU Lesser General Public License for more details.
9		*
10		* The License is available on the internet at:
11		* http://www.gnu.org/copyleft/lgpl.html
12		* or by writing to:
13		* Free Software Foundation, Inc.
14		* 59 Temple Place - Suite 330
15		* Boston, MA 02111-1307, USA
16		*
17		* © CrossWire Bible Society, 2008 - 2016
18		*
19		*/
20		package org.crosswire.common.util;
21
22		import java.io.IOException;
23		import java.io.InputStream;
24		import java.io.OutputStream;
25		import java.util.Enumeration;
26		import java.util.LinkedHashMap;
27		import java.util.Properties;
28
29
30		/**
31		* A PropertyMap is a Map<String,String> sitting over top a Property file.
32		* As such it must be defined in the same way as a java.util.Properties expects.
33		*
34		* @see java.util.Properties
35		* @see gnu.lgpl.License The GNU Lesser General Public License for details.
36		* @author DM Smith
37		*/
38		public class PropertyMap extends LinkedHashMap<String, String> {
39		/**
40		* Creates an empty property list with no default values.
41		*/
42		public PropertyMap() {
43	0	this(null);
44	0	}
45
46		/**
47		* Creates an empty property map with the specified defaults.
48		*
49		* @param defaults the defaults.
50		*/
51	0	public PropertyMap(PropertyMap defaults) {
52	0	this.defaults = defaults;
53	0	}
54
55		/**
56		* Searches for the property with the specified key in this property list.
57		* If the key is not found in this property list, the default property list,
58		* and its defaults, recursively, are then checked. The method returns
59		* <code>null</code> if the property is not found.
60		*
61		* @param key the lookup key.
62		* @return the value in this property list with the specified key value.
63		* @see java.util.Properties#setProperty
64		*/
65		public String get(String key) {
66	0	String value = super.get(key);
67	0	return ((value == null) && (defaults != null)) ? defaults.get(key) : value;
68		}
69
70		/**
71		* Searches for the property with the specified key in this property list.
72		* If the key is not found in this property list, the default property list,
73		* and its defaults, recursively, are then checked. The method returns the
74		* default value argument if the property is not found.
75		*
76		* @param key the lookup key.
77		* @param defaultValue a default value.
78		*
79		* @return the value in this property list with the specified key value.
80		* @see java.util.Properties#setProperty
81		*/
82		public String get(String key, String defaultValue) {
83	0	String value = get(key);
84	0	return value == null ? defaultValue : value;
85		}
86
87		/**
88		* Reads a property list (key and element pairs) from the input
89		* byte stream. The input stream is in a simple line-oriented
90		* format as specified in
91		* {@link java.util.Properties#load(java.io.InputStream) load(InputStream)} and is assumed to use
92		* the ISO 8859-1 character encoding; that is each byte is one Latin1
93		* character. Characters not in Latin1, and certain special characters,
94		* are represented in keys and elements using
95		* <a href="http://java.sun.com/docs/books/jls/third_edition/html/lexical.html#3.3">Unicode escapes</a>.
96		* <p>
97		* The specified stream remains open after this method returns.
98		*
99		* @param inStream the input stream.
100		* @exception IOException if an error occurred when reading from the
101		* input stream.
102		* @throws IllegalArgumentException if the input stream contains a
103		* malformed Unicode escape sequence.
104		* @since 1.2
105		*/
106		public void load(InputStream inStream) throws IOException {
107	0	Properties prop = new Properties();
108	0	prop.load(inStream);
109	0	for (Enumeration<Object> e = prop.keys(); e.hasMoreElements(); ) {
110	0	Object k = e.nextElement();
111	0	Object v = prop.get(k);
112	0	if (k instanceof String && v instanceof String) {
113	0	put((String) k, (String) v);
114		}
115	0	}
116	0	}
117
118		/**
119		* Writes this property list (key and element pairs) in this
120		* <code>PropertyMap</code> table to the output stream in a format suitable
121		* for loading into a <code>PropertyMap</code> table using the
122		* {@link #load(InputStream) load(InputStream)} method.
123		* <p>
124		* Properties from the defaults table of this <code>PropertyMap</code>
125		* table (if any) are <i>not</i> written out by this method.
126		* <p>
127		* This method outputs the comments, properties keys and values in
128		* the same format as specified in
129		* {@link java.util.Properties#store(java.io.OutputStream, java.lang.String) store(Writer)},
130		* <p>
131		* After the entries have been written, the output stream is flushed.
132		* The output stream remains open after this method returns.
133		* <p>
134		* @param out an output stream.
135		* @param comments a description of the property list.
136		* @exception IOException if writing this property list to the specified
137		* output stream throws an <tt>IOException</tt>.
138		* @exception NullPointerException if <code>out</code> is null.
139		* @since 1.2
140		*/
141		public void store(OutputStream out, String comments) throws IOException {
142	0	Properties temp = new Properties();
143	0	temp.putAll(this);
144	0	temp.store(out, comments);
145	0	}
146
147		/**
148		* Default values for any keys not found in this property map.
149		*/
150		private PropertyMap defaults;
151
152		/**
153		* Serialization ID
154		*/
155		private static final long serialVersionUID = 2821277155924802795L;
156		}