%line	%branch
org.apache.jcs.utils.props.PropertyLoader	73%	95%

1		package org.apache.jcs.utils.props;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.InputStream;
23		import java.util.Properties;
24
25		/**
26		* I modified this class to work with .ccf files in particular. I also removed
27		* the resource bundle functionality.
28		* <p>
29		* A simple class for loading java.util.Properties backed by .ccf files deployed
30		* as classpath resources. See individual methods for details.
31		* <p>
32		* The original source is from:
33		* <p>
34		* @author (C) <a
35		* href="http://www.javaworld.com/columns/jw-qna-index.shtml">Vlad
36		* Roubtsov </a>, 2003
37		*/
38		public abstract class PropertyLoader
39		{
40		private static final boolean THROW_ON_LOAD_FAILURE = true;
41
42		private static final String SUFFIX = ".ccf";
43
44		private static final String SUFFIX_PROPERTIES = ".properties";
45
46		/**
47		* Looks up a resource named 'name' in the classpath. The resource must map
48		* to a file with .ccf extention. The name is assumed to be absolute and can
49		* use either "/" or "." for package segment separation with an optional
50		* leading "/" and optional ".ccf" suffix.
51		* <p>
52		* The suffix ".ccf" will be appended if it is not set. This can also handle
53		* .properties files
54		* <p>
55		* Thus, the following names refer to the same resource:
56		*
57		* <pre>
58		*
59		* some.pkg.Resource
60		* some.pkg.Resource.ccf
61		* some/pkg/Resource
62		* some/pkg/Resource.ccf
63		* /some/pkg/Resource
64		* /some/pkg/Resource.ccf
65		* </pre>
66		*
67		* @param name
68		* classpath resource name [may not be null]
69		* @param loader
70		* classloader through which to load the resource [null is
71		* equivalent to the application loader]
72		* @return resource converted to java.util.properties [may be null if the
73		* resource was not found and THROW_ON_LOAD_FAILURE is false]
74		* @throws IllegalArgumentException
75		* if the resource was not found and THROW_ON_LOAD_FAILURE is
76		* true
77		*/
78		public static Properties loadProperties( String name, ClassLoader loader )
79		{
80	92	boolean isCCFSuffix = true;
81
82	92	if ( name == null )
83	0	throw new IllegalArgumentException( "null input: name" );
84
85	92	if ( name.startsWith( "/" ) )
86		{
87	0	name = name.substring( 1 );
88		}
89
90	92	if ( name.endsWith( SUFFIX ) )
91		{
92	52	name = name.substring( 0, name.length() - SUFFIX.length() );
93		}
94
95	92	if ( name.endsWith( SUFFIX_PROPERTIES ) )
96		{
97	40	name = name.substring( 0, name.length() - SUFFIX_PROPERTIES.length() );
98	40	isCCFSuffix = false;
99		}
100
101	92	Properties result = null;
102
103	92	InputStream in = null;
104		try
105		{
106	92	if ( loader == null )
107		{
108	0	loader = ClassLoader.getSystemClassLoader();
109		}
110
111	92	name = name.replace( '.', '/' );
112
113	92	if ( !name.endsWith( SUFFIX ) && isCCFSuffix )
114		{
115	52	name = name.concat( SUFFIX );
116	49	}
117	40	else if ( !name.endsWith( SUFFIX_PROPERTIES ) && !isCCFSuffix )
118		{
119	40	name = name.concat( SUFFIX_PROPERTIES );
120		}
121
122		// returns null on lookup failures:
123	92	in = loader.getResourceAsStream( name );
124	92	if ( in != null )
125		{
126	92	result = new Properties();
127	92	result.load( in ); // can throw IOException
128		}
129		}
130	0	catch ( Exception e )
131		{
132	0	result = null;
133		}
134		finally
135		{
136	92	if ( in != null )
137		try
138		{
139	92	in.close();
140		}
141	0	catch ( Throwable ignore )
142		{
143		// swallow
144	84	}
145	0	}
146
147	92	if ( THROW_ON_LOAD_FAILURE && ( result == null ) )
148		{
149	0	throw new IllegalArgumentException( "could not load [" + name + "]" + " as " + "a classloader resource" );
150		}
151
152	92	return result;
153		}
154
155		/**
156		* A convenience overload of {@link #loadProperties(String, ClassLoader)}
157		* that uses the current thread's context classloader. A better strategy
158		* would be to use techniques shown in
159		* http://www.javaworld.com/javaworld/javaqa/2003-06/01-qa-0606-load.html
160		* <p>
161		* @param name
162		* @return Properties
163		*/
164		public static Properties loadProperties( final String name )
165		{
166	92	return loadProperties( name, Thread.currentThread().getContextClassLoader() );
167		}
168
169		/**
170		* Can't use this one.
171		*/
172		private PropertyLoader()
173		{
174	0	super();
175	0	} // this class is not extentible
176
177		}

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