%line	%branch
org.apache.commons.configuration.HierarchicalXMLConfiguration$1	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.io.File;
20		import java.io.InputStream;
21		import java.io.OutputStream;
22		import java.io.Reader;
23		import java.io.Writer;
24		import java.net.URL;
25		import javax.xml.parsers.DocumentBuilder;
26		import javax.xml.parsers.DocumentBuilderFactory;
27
28		import org.w3c.dom.Attr;
29		import org.w3c.dom.Document;
30		import org.w3c.dom.Element;
31		import org.w3c.dom.NamedNodeMap;
32		import org.w3c.dom.NodeList;
33		import org.w3c.dom.Text;
34		import org.xml.sax.InputSource;
35
36		/**
37		* A specialized hierarchical configuration class that is able to parse
38		* XML documents.
39		*
40		* <p>The parsed document will be stored keeping its structure. The
41		* contained properties can be accessed using all methods supported by
42		* the base class <code>HierarchicalConfiguration</code>.
43		*
44		* @since commons-configuration 1.0
45		*
46		* @author J&ouml;rg Schaible
47		* @author <a href="mailto:oliver.heger@t-online.de">Oliver Heger</a>
48		* @version $Revision: 1.3 $, $Date: 2004/09/22 17:17:30 $
49		*/
50		public class HierarchicalXMLConfiguration extends HierarchicalConfiguration implements FileConfiguration
51		{
52		private FileConfiguration delegate = new FileConfigurationDelegate();
53
54		/**
55		* Initializes this configuration from an XML document.
56		*
57		* @param document the document to be parsed
58		*/
59		public void initProperties(Document document)
60		{
61		constructHierarchy(getRoot(), document.getDocumentElement());
62		}
63
64		/**
65		* Helper method for building the internal storage hierarchy. The XML
66		* elements are transformed into node objects.
67		*
68		* @param node the actual node
69		* @param element the actual XML element
70		*/
71		private void constructHierarchy(Node node, Element element)
72		{
73		StringBuffer buffer = new StringBuffer();
74		NodeList list = element.getChildNodes();
75		for (int i = 0; i < list.getLength(); i++)
76		{
77		org.w3c.dom.Node w3cNode = list.item(i);
78		if (w3cNode instanceof Element)
79		{
80		Element child = (Element) w3cNode;
81		Node childNode = new Node(child.getTagName());
82		constructHierarchy(childNode, child);
83		node.addChild(childNode);
84		processAttributes(childNode, child);
85		}
86		else if (w3cNode instanceof Text)
87		{
88		Text data = (Text) w3cNode;
89		buffer.append(data.getData());
90		}
91		}
92		String text = buffer.toString().trim();
93		if (text.length() > 0)
94		{
95		node.setValue(text);
96		}
97		}
98
99		/**
100		* Helper method for constructing node objects for the attributes of the
101		* given XML element.
102		*
103		* @param node the actual node
104		* @param element the actual XML element
105		*/
106		private void processAttributes(Node node, Element element)
107		{
108		NamedNodeMap attributes = element.getAttributes();
109		for (int i = 0; i < attributes.getLength(); ++i)
110		{
111		org.w3c.dom.Node w3cNode = attributes.item(i);
112		if (w3cNode instanceof Attr)
113		{
114		Attr attr = (Attr) w3cNode;
115		Node child =
116		new Node(
117		ConfigurationKey.constructAttributeKey(attr.getName()));
118		child.setValue(attr.getValue());
119		node.addChild(child);
120		}
121		}
122		}
123
124		public void load() throws ConfigurationException
125		{
126		delegate.load();
127		}
128
129		public void load(String fileName) throws ConfigurationException
130		{
131		delegate.load(fileName);
132		}
133
134		public void load(File file) throws ConfigurationException
135		{
136		delegate.load(file);
137		}
138
139		public void load(URL url) throws ConfigurationException
140		{
141		delegate.load(url);
142		}
143
144		public void load(InputStream in) throws ConfigurationException
145		{
146		delegate.load(in);
147		}
148
149		public void load(InputStream in, String encoding) throws ConfigurationException
150		{
151		delegate.load(in, encoding);
152		}
153
154		public void load(Reader in) throws ConfigurationException
155		{
156		try
157		{
158		DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
159		initProperties(builder.parse(new InputSource(in)));
160		}
161		catch (Exception e)
162		{
163		throw new ConfigurationException(e.getMessage(), e);
164		}
165		}
166
167		public void save() throws ConfigurationException
168		{
169		delegate.save();
170		}
171
172		public void save(String fileName) throws ConfigurationException
173		{
174		delegate.save(fileName);
175		}
176
177		public void save(File file) throws ConfigurationException
178		{
179		delegate.save(file);
180		}
181
182		public void save(URL url) throws ConfigurationException
183		{
184		delegate.save(url);
185		}
186
187		public void save(OutputStream out) throws ConfigurationException
188		{
189		delegate.save(out);
190		}
191
192		public void save(OutputStream out, String encoding) throws ConfigurationException
193		{
194		delegate.save(out, encoding);
195		}
196
197		public void save(Writer out) throws ConfigurationException
198		{
199		throw new UnsupportedOperationException("Can't save HierarchicalXMLConfigurations");
200		}
201
202		public String getFileName()
203		{
204		return delegate.getFileName();
205		}
206
207		public void setFileName(String fileName)
208		{
209		delegate.setFileName(fileName);
210		}
211
212		public String getBasePath()
213		{
214		return delegate.getBasePath();
215		}
216
217		public void setBasePath(String basePath)
218		{
219		delegate.setBasePath(basePath);
220		}
221
222		public File getFile()
223		{
224		return delegate.getFile();
225		}
226
227		public void setFile(File file)
228		{
229		delegate.setFile(file);
230		}
231
232		public URL getURL()
233		{
234		return delegate.getURL();
235		}
236
237		public void setURL(URL url)
238		{
239		delegate.setURL(url);
240		}
241
242		private class FileConfigurationDelegate extends AbstractFileConfiguration {
243
244		public void load(Reader in) throws ConfigurationException
245		{
246		HierarchicalXMLConfiguration.this.load(in);
247		}
248
249		public void save(Writer out) throws ConfigurationException
250		{
251		HierarchicalXMLConfiguration.this.save(out);
252		}
253
254		}
255		}

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