1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.configuration;
18
19 import java.io.File;
20 import java.io.FileNotFoundException;
21 import java.io.FileOutputStream;
22 import java.io.IOException;
23 import java.io.InputStream;
24 import java.io.InputStreamReader;
25 import java.io.OutputStream;
26 import java.io.OutputStreamWriter;
27 import java.io.Reader;
28 import java.io.UnsupportedEncodingException;
29 import java.io.Writer;
30 import java.net.MalformedURLException;
31 import java.net.URL;
32
33 /***
34 * Partial implementation of the <code>FileConfiguration</code> interface.
35 * Developpers of file based configuration may wan't to extend this class,
36 * the two methods left to implement are {@see AbstractFileConfiguration#load(Reader)}
37 * and {@see AbstractFileConfiguration#save(Reader)}.
38 *
39 * @author Emmanuel Bourg
40 * @version $Revision: 1.4 $, $Date: 2004/10/04 21:45:10 $
41 * @since 1.0-rc2
42 */
43 public abstract class AbstractFileConfiguration extends BaseConfiguration implements FileConfiguration
44 {
45 protected String fileName;
46 protected String basePath;
47 protected URL url;
48
49 /***
50 * Load the configuration from the underlying URL. If the URL is not
51 * specified, it attempts to locate the specified file name.
52 *
53 * @throws ConfigurationException
54 */
55 public void load() throws ConfigurationException
56 {
57 if (url == null)
58 {
59 load(fileName);
60 }
61 else
62 {
63 load(url);
64 }
65 }
66
67 /***
68 * Locate the specified file and load the configuration.
69 *
70 * @param fileName the name of the file loaded
71 *
72 * @throws ConfigurationException
73 */
74 public void load(String fileName) throws ConfigurationException
75 {
76 try
77 {
78 URL url = ConfigurationUtils.locate(basePath, fileName);
79 load(url);
80 }
81 catch (ConfigurationException e)
82 {
83 throw e;
84 }
85 catch (Exception e)
86 {
87 throw new ConfigurationException(e.getMessage(), e);
88 }
89 }
90
91 /***
92 * Load the configuration from the specified file.
93 *
94 * @param file the loaded file
95 *
96 * @throws ConfigurationException
97 */
98 public void load(File file) throws ConfigurationException
99 {
100 try
101 {
102 load(file.toURL());
103 }
104 catch (MalformedURLException e)
105 {
106 throw new ConfigurationException(e.getMessage(), e);
107 }
108 }
109
110 /***
111 * Load the configuration from the specified URL.
112 *
113 * @param url the URL of the file loaded
114 *
115 * @throws ConfigurationException
116 */
117 public void load(URL url) throws ConfigurationException
118 {
119 InputStream in = null;
120
121 try
122 {
123 in = url.openStream();
124 load(in);
125 }
126 catch (Exception e)
127 {
128 throw new ConfigurationException(e.getMessage(), e);
129 }
130 finally
131 {
132
133 try
134 {
135 if (in != null)
136 {
137 in.close();
138 }
139 }
140 catch (IOException e)
141 {
142 e.printStackTrace();
143 }
144 }
145 }
146
147 /***
148 * Load the configuration from the specified stream, using the default
149 * platform specific encoding.
150 *
151 * @param in the input stream
152 *
153 * @throws ConfigurationException
154 */
155 public void load(InputStream in) throws ConfigurationException
156 {
157 load(in, null);
158 }
159
160 /***
161 * Load the configuration from the specified stream, using the specified
162 * encoding. If the encoding is null the default encoding is used.
163 *
164 * @param in the input stream
165 * @param encoding the encoding used. <code>null</code> to use the default encoding
166 *
167 * @throws ConfigurationException
168 */
169 public void load(InputStream in, String encoding) throws ConfigurationException
170 {
171 Reader reader = null;
172
173 if (encoding != null)
174 {
175 try
176 {
177 reader = new InputStreamReader(in, encoding);
178 }
179 catch (UnsupportedEncodingException e)
180 {
181 throw new ConfigurationException("The requested encoding is not supported, try the default encoding.", e);
182 }
183 }
184
185 if (reader == null)
186 {
187 reader = new InputStreamReader(in);
188 }
189
190 load(reader);
191 }
192
193 /***
194 * Save the configuration.
195 *
196 * @throws ConfigurationException
197 */
198 public void save() throws ConfigurationException
199 {
200 save(fileName);
201 }
202
203 /***
204 * Save the configuration to the specified file. This doesn't change the
205 * source of the configuration, use setFileName() if you need it.
206 *
207 * @param fileName
208 *
209 * @throws ConfigurationException
210 */
211 public void save(String fileName) throws ConfigurationException
212 {
213 try
214 {
215
216 save(ConfigurationUtils.constructFile(basePath, fileName));
217 }
218 catch (ConfigurationException e)
219 {
220 throw e;
221 }
222 catch (Exception e)
223 {
224 throw new ConfigurationException(e.getMessage(), e);
225 }
226 }
227
228 /***
229 * Save the configuration to the specified URL if it's a file URL.
230 * This doesn't change the source of the configuration, use setURL()
231 * if you need it.
232 *
233 * @param url
234 *
235 * @throws ConfigurationException
236 */
237 public void save(URL url) throws ConfigurationException
238 {
239 if ("file".equals(url.getProtocol()))
240 {
241 save(new File(url.getFile()));
242 }
243 }
244
245 /***
246 * Save the configuration to the specified file. This doesn't change the
247 * source of the configuration, use setFile() if you need it.
248 *
249 * @param file
250 *
251 * @throws ConfigurationException
252 */
253 public void save(File file) throws ConfigurationException
254 {
255 OutputStream out = null;
256
257 try
258 {
259 out = new FileOutputStream(file);
260 save(out);
261 }
262 catch (FileNotFoundException e)
263 {
264 e.printStackTrace();
265 }
266 finally
267 {
268
269 try
270 {
271 if (out != null)
272 {
273 out.close();
274 }
275 }
276 catch (IOException e)
277 {
278 e.printStackTrace();
279 }
280 }
281 }
282
283 /***
284 * Save the configuration to the specified stream.
285 *
286 * @param out
287 *
288 * @throws ConfigurationException
289 */
290 public void save(OutputStream out) throws ConfigurationException
291 {
292 save(out, null);
293 }
294
295 /***
296 * Save the configuration to the specified stream, using the specified
297 * encoding. If the encoding is null the default encoding is used.
298 *
299 * @param out
300 * @param encoding
301 * @throws ConfigurationException
302 */
303 public void save(OutputStream out, String encoding) throws ConfigurationException
304 {
305 Writer writer = null;
306
307 if (encoding != null)
308 {
309 try
310 {
311 writer = new OutputStreamWriter(out, encoding);
312 }
313 catch (UnsupportedEncodingException e)
314 {
315 throw new ConfigurationException("The requested encoding is not supported, try the default encoding.", e);
316 }
317 }
318
319 if (writer == null)
320 {
321 writer = new OutputStreamWriter(out);
322 }
323
324 save(writer);
325 }
326
327 /***
328 * Return the name of the file.
329 */
330 public String getFileName()
331 {
332 return fileName;
333 }
334
335 /***
336 * Set the name of the file.
337 *
338 * @param fileName the name of the file
339 */
340 public void setFileName(String fileName)
341 {
342 this.fileName = fileName;
343
344
345 url = ConfigurationUtils.locate(basePath, fileName);
346 }
347
348 /***
349 * Return the base path.
350 */
351 public String getBasePath()
352 {
353 return basePath;
354 }
355
356 /***
357 * Set the base path. Relative configurations are loaded from this path.
358 *
359 * @param basePath the base path.
360 */
361 public void setBasePath(String basePath)
362 {
363 this.basePath = basePath;
364
365
366 }
367
368 /***
369 * Return the file where the configuration is stored.
370 */
371 public File getFile()
372 {
373 if (url != null && "file".equals(url.getProtocol()))
374 {
375 return new File(url.getFile());
376 }
377 else
378 {
379 return ConfigurationUtils.constructFile(getBasePath(), getFileName());
380 }
381 }
382
383 /***
384 * Set the file where the configuration is stored.
385 *
386 * @param file
387 */
388 public void setFile(File file)
389 {
390 if (file != null)
391 {
392 try
393 {
394 setURL(file.toURL());
395 }
396 catch (MalformedURLException e)
397 {
398 e.printStackTrace();
399 }
400 }
401 else
402 {
403 url = null;
404 }
405 }
406
407 /***
408 * Return the URL where the configuration is stored.
409 */
410 public URL getURL()
411 {
412 return url;
413 }
414
415 /***
416 * The URL where the configuration is stored.
417 *
418 * @param url
419 */
420 public void setURL(URL url)
421 {
422 this.url = url;
423
424
425 basePath = ConfigurationUtils.getBasePath(url);
426 if (basePath != null && basePath.startsWith("file:"))
427 {
428 basePath = basePath.substring(5);
429 }
430
431
432 fileName = ConfigurationUtils.getFileName(url);
433 }
434 }