Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.configuration.SubsetConfiguration$1 |
100% |
100% |

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

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.