Coverage Report

 /*
  * 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.commons.configuration;
 
 import java.util.Iterator;
 
 import org.apache.commons.collections.Transformer;
 import org.apache.commons.collections.iterators.TransformIterator;
 
 /**
  * <p>A subset of another configuration. The new Configuration object contains
  * every key from the parent Configuration that starts with prefix. The prefix
  * is removed from the keys in the subset.</p>
  * <p>It is usually not necessary to use this class directly. Instead the
  * <code>{@link Configuration#subset(String)}</code> method should be used,
  * which will return a correctly initialized instance.</p>
  *
  * @author Emmanuel Bourg
  * @version $Revision: 439648 $, $Date: 2006-09-02 22:42:10 +0200 (Sa, 02 Sep 2006) $
  */
 public class SubsetConfiguration extends AbstractConfiguration
 {
     /** The parent configuration. */
     protected Configuration parent;
 
     /** The prefix used to select the properties. */
     protected String prefix;
 
     /** The prefix delimiter */
     protected String delimiter;
 
     /**
      * Create a subset of the specified configuration
      *
      * @param parent The parent configuration
      * @param prefix The prefix used to select the properties
      */
     public SubsetConfiguration(Configuration parent, String prefix)
     {
         this.parent = parent;
         this.prefix = prefix;
     }
 
     /**
      * Create a subset of the specified configuration
      *
      * @param parent    The parent configuration
      * @param prefix    The prefix used to select the properties
      * @param delimiter The prefix delimiter
      */
     public SubsetConfiguration(Configuration parent, String prefix, String delimiter)
     {
         this.parent = parent;
         this.prefix = prefix;
         this.delimiter = delimiter;
     }
 
     /**
      * Return the key in the parent configuration associated to the specified
      * key in this subset.
      *
      * @param key The key in the subset.
      * @return the key as to be used by the parent
      */
     protected String getParentKey(String key)
     {
         if ("".equals(key) || key == null)
         {
             return prefix;
         }
         else
         {
             return delimiter == null ? prefix + key : prefix + delimiter + key;
         }
     }
 
     /**
      * Return the key in the subset configuration associated to the specified
      * key in the parent configuration.
      *
      * @param key The key in the parent configuration.
      * @return the key in the context of this subset configuration
      */
     protected String getChildKey(String key)
     {
         if (!key.startsWith(prefix))
         {
             throw new IllegalArgumentException("The parent key '" + key + "' is not in the subset.");
         }
         else
         {
             String modifiedKey = null;
             if (key.length() == prefix.length())
             {
                 modifiedKey = "";
             }
             else
             {
                 int i = prefix.length() + (delimiter != null ? delimiter.length() : 0);
                 modifiedKey = key.substring(i);
             }
 
             return modifiedKey;
         }
     }
 
     /**
      * Return the parent configuation for this subset.
      *
      * @return the parent configuration
      */
     public Configuration getParent()
     {
         return parent;
     }
 
     /**
      * Return the prefix used to select the properties in the parent configuration.
      *
      * @return the prefix used by this subset
      */
     public String getPrefix()
     {
         return prefix;
     }
 
     /**
      * Set the prefix used to select the properties in the parent configuration.
      *
      * @param prefix the prefix
      */
     public void setPrefix(String prefix)
     {
         this.prefix = prefix;
     }
 
     /**
      * {@inheritDoc}
      */
     public Configuration subset(String prefix)
     {
         return parent.subset(getParentKey(prefix));
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean isEmpty()
     {
         return !getKeys().hasNext();
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean containsKey(String key)
     {
         return parent.containsKey(getParentKey(key));
     }
 
     /**
      * {@inheritDoc}
      */
     public void addPropertyDirect(String key, Object value)
     {
         parent.addProperty(getParentKey(key), value);
     }
 
     /**
      * {@inheritDoc}
      */
     public void setProperty(String key, Object value)
     {
         parent.setProperty(getParentKey(key), value);
     }
 
     /**
      * {@inheritDoc}
      */
     public void clearProperty(String key)
     {
         parent.clearProperty(getParentKey(key));
     }
 
     /**
      * {@inheritDoc}
      */
     public Object getProperty(String key)
     {
         return parent.getProperty(getParentKey(key));
     }
 
     /**
      * {@inheritDoc}
      */
     public Iterator getKeys(String prefix)
     {
         return new TransformIterator(parent.getKeys(getParentKey(prefix)), new Transformer()
         {
             public Object transform(Object obj)
             {
                 return getChildKey((String) obj);
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     public Iterator getKeys()
     {
         return new TransformIterator(parent.getKeys(prefix), new Transformer()
         {
             public Object transform(Object obj)
             {
                 return getChildKey((String) obj);
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     protected String interpolate(String base)
     {
         if (delimiter == null && "".equals(prefix))
         {
             return super.interpolate(base);
         }
         else
         {
             SubsetConfiguration config = new SubsetConfiguration(parent, "");
             return config.interpolate(base);
         }
     }
 
     /**
      * {@inheritDoc}
      *
      * Change the behaviour of the parent configuration if it supports this feature.
      */
     public void setThrowExceptionOnMissing(boolean throwExceptionOnMissing)
     {
         if (parent instanceof AbstractConfiguration)
         {
             ((AbstractConfiguration) parent).setThrowExceptionOnMissing(throwExceptionOnMissing);
         }
         else
         {
             super.setThrowExceptionOnMissing(throwExceptionOnMissing);
         }
     }
 
     /**
      * {@inheritDoc}
      *
      * The subset inherits this feature from its parent if it supports this feature.
      */
     public boolean isThrowExceptionOnMissing()
     {
         if (parent instanceof AbstractConfiguration)
         {
             return ((AbstractConfiguration) parent).isThrowExceptionOnMissing();
         }
         else
         {
             return super.isThrowExceptionOnMissing();
         }
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		package org.apache.commons.configuration;
19
20		import java.util.Iterator;
21
22		import org.apache.commons.collections.Transformer;
23		import org.apache.commons.collections.iterators.TransformIterator;
24
25		/**
26		* <p>A subset of another configuration. The new Configuration object contains
27		* every key from the parent Configuration that starts with prefix. The prefix
28		* is removed from the keys in the subset.</p>
29		* <p>It is usually not necessary to use this class directly. Instead the
30		* <code>{@link Configuration#subset(String)}</code> method should be used,
31		* which will return a correctly initialized instance.</p>
32		*
33		* @author Emmanuel Bourg
34		* @version $Revision: 439648 $, $Date: 2006-09-02 22:42:10 +0200 (Sa, 02 Sep 2006) $
35		*/
36		public class SubsetConfiguration extends AbstractConfiguration
37		{
38		/** The parent configuration. */
39		protected Configuration parent;
40
41		/** The prefix used to select the properties. */
42		protected String prefix;
43
44		/** The prefix delimiter */
45		protected String delimiter;
46
47		/**
48		* Create a subset of the specified configuration
49		*
50		* @param parent The parent configuration
51		* @param prefix The prefix used to select the properties
52		*/
53		public SubsetConfiguration(Configuration parent, String prefix)
54	15	{
55	15	this.parent = parent;
56	15	this.prefix = prefix;
57	15	}
58
59		/**
60		* Create a subset of the specified configuration
61		*
62		* @param parent The parent configuration
63		* @param prefix The prefix used to select the properties
64		* @param delimiter The prefix delimiter
65		*/
66		public SubsetConfiguration(Configuration parent, String prefix, String delimiter)
67	52	{
68	52	this.parent = parent;
69	52	this.prefix = prefix;
70	52	this.delimiter = delimiter;
71	52	}
72
73		/**
74		* Return the key in the parent configuration associated to the specified
75		* key in this subset.
76		*
77		* @param key The key in the subset.
78		* @return the key as to be used by the parent
79		*/
80		protected String getParentKey(String key)
81		{
82	49	if ("".equals(key) \|\| key == null)
83		{
84	4	return prefix;
85		}
86		else
87		{
88	45	return delimiter == null ? prefix + key : prefix + delimiter + key;
89		}
90		}
91
92		/**
93		* Return the key in the subset configuration associated to the specified
94		* key in the parent configuration.
95		*
96		* @param key The key in the parent configuration.
97		* @return the key in the context of this subset configuration
98		*/
99		protected String getChildKey(String key)
100		{
101	102	if (!key.startsWith(prefix))
102		{
103	0	throw new IllegalArgumentException("The parent key '" + key + "' is not in the subset.");
104		}
105		else
106		{
107	102	String modifiedKey = null;
108	102	if (key.length() == prefix.length())
109		{
110	4	modifiedKey = "";
111		}
112		else
113		{
114	98	int i = prefix.length() + (delimiter != null ? delimiter.length() : 0);
115	98	modifiedKey = key.substring(i);
116		}
117
118	102	return modifiedKey;
119		}
120		}
121
122		/**
123		* Return the parent configuation for this subset.
124		*
125		* @return the parent configuration
126		*/
127		public Configuration getParent()
128		{
129	1	return parent;
130		}
131
132		/**
133		* Return the prefix used to select the properties in the parent configuration.
134		*
135		* @return the prefix used by this subset
136		*/
137		public String getPrefix()
138		{
139	2	return prefix;
140		}
141
142		/**
143		* Set the prefix used to select the properties in the parent configuration.
144		*
145		* @param prefix the prefix
146		*/
147		public void setPrefix(String prefix)
148		{
149	1	this.prefix = prefix;
150	1	}
151
152		/**
153		* {@inheritDoc}
154		*/
155		public Configuration subset(String prefix)
156		{
157	1	return parent.subset(getParentKey(prefix));
158		}
159
160		/**
161		* {@inheritDoc}
162		*/
163		public boolean isEmpty()
164		{
165	8	return !getKeys().hasNext();
166		}
167
168		/**
169		* {@inheritDoc}
170		*/
171		public boolean containsKey(String key)
172		{
173	10	return parent.containsKey(getParentKey(key));
174		}
175
176		/**
177		* {@inheritDoc}
178		*/
179		public void addPropertyDirect(String key, Object value)
180		{
181	0	parent.addProperty(getParentKey(key), value);
182	0	}
183
184		/**
185		* {@inheritDoc}
186		*/
187		public void setProperty(String key, Object value)
188		{
189	4	parent.setProperty(getParentKey(key), value);
190	4	}
191
192		/**
193		* {@inheritDoc}
194		*/
195		public void clearProperty(String key)
196		{
197	1	parent.clearProperty(getParentKey(key));
198	1	}
199
200		/**
201		* {@inheritDoc}
202		*/
203		public Object getProperty(String key)
204		{
205	28	return parent.getProperty(getParentKey(key));
206		}
207
208		/**
209		* {@inheritDoc}
210		*/
211		public Iterator getKeys(String prefix)
212		{
213	1	return new TransformIterator(parent.getKeys(getParentKey(prefix)), new Transformer()
214		{
215	1	public Object transform(Object obj)
216		{
217	2	return getChildKey((String) obj);
218		}
219		});
220		}
221
222		/**
223		* {@inheritDoc}
224		*/
225		public Iterator getKeys()
226		{
227	24	return new TransformIterator(parent.getKeys(prefix), new Transformer()
228		{
229	24	public Object transform(Object obj)
230		{
231	96	return getChildKey((String) obj);
232		}
233		});
234		}
235
236		/**
237		* {@inheritDoc}
238		*/
239		protected String interpolate(String base)
240		{
241	28	if (delimiter == null && "".equals(prefix))
242		{
243	14	return super.interpolate(base);
244		}
245		else
246		{
247	14	SubsetConfiguration config = new SubsetConfiguration(parent, "");
248	14	return config.interpolate(base);
249		}
250		}
251
252		/**
253		* {@inheritDoc}
254		*
255		* Change the behaviour of the parent configuration if it supports this feature.
256		*/
257		public void setThrowExceptionOnMissing(boolean throwExceptionOnMissing)
258		{
259	1	if (parent instanceof AbstractConfiguration)
260		{
261	1	((AbstractConfiguration) parent).setThrowExceptionOnMissing(throwExceptionOnMissing);
262		}
263		else
264		{
265	0	super.setThrowExceptionOnMissing(throwExceptionOnMissing);
266		}
267	1	}
268
269		/**
270		* {@inheritDoc}
271		*
272		* The subset inherits this feature from its parent if it supports this feature.
273		*/
274		public boolean isThrowExceptionOnMissing()
275		{
276	2	if (parent instanceof AbstractConfiguration)
277		{
278	2	return ((AbstractConfiguration) parent).isThrowExceptionOnMissing();
279		}
280		else
281		{
282	0	return super.isThrowExceptionOnMissing();
283		}
284		}
285		}