KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > tomcat > util > res > StringManager


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.tomcat.util.res;
19
20 import java.text.MessageFormat JavaDoc;
21 import java.util.Hashtable JavaDoc;
22 import java.util.Locale JavaDoc;
23 import java.util.MissingResourceException JavaDoc;
24 import java.util.ResourceBundle JavaDoc;
25
26 /**
27  * An internationalization / localization helper class which reduces
28  * the bother of handling ResourceBundles and takes care of the
29  * common cases of message formating which otherwise require the
30  * creation of Object arrays and such.
31  *
32  * <p>The StringManager operates on a package basis. One StringManager
33  * per package can be created and accessed via the getManager method
34  * call.
35  *
36  * <p>The StringManager will look for a ResourceBundle named by
37  * the package name given plus the suffix of "LocalStrings". In
38  * practice, this means that the localized information will be contained
39  * in a LocalStrings.properties file located in the package
40  * directory of the classpath.
41  *
42  * <p>Please see the documentation for java.util.ResourceBundle for
43  * more information.
44  *
45  * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
46  *
47  * @author James Duncan Davidson [duncan@eng.sun.com]
48  * @author James Todd [gonzo@eng.sun.com]
49  * @author Mel Martinez [mmartinez@g1440.com]
50  * @see java.util.ResourceBundle
51  */
52
53 public class StringManager {
54
55     /**
56      * The ResourceBundle for this StringManager.
57      */
58
59     private ResourceBundle JavaDoc bundle;
60     private Locale JavaDoc locale;
61
62     /**
63      * Creates a new StringManager for a given package. This is a
64      * private method and all access to it is arbitrated by the
65      * static getManager method call so that only one StringManager
66      * per package will be created.
67      *
68      * @param packageName Name of package to create StringManager for.
69      */
70
71     private StringManager(String JavaDoc packageName) {
72     this( packageName, Locale.getDefault() );
73     }
74
75     private StringManager(String JavaDoc packageName, Locale JavaDoc loc) {
76         String JavaDoc bundleName = packageName + ".LocalStrings";
77         bundle = ResourceBundle.getBundle(bundleName, loc);
78         // Get the actual locale, which may be different from the requested one
79 locale = bundle.getLocale();
80     }
81
82     private StringManager(ResourceBundle JavaDoc bundle )
83     {
84     this.bundle=bundle;
85         locale = bundle.getLocale();
86     }
87
88     /**
89         Get a string from the underlying resource bundle or return
90         null if the String is not found.
91      
92         @param key to desired resource String
93         @return resource String matching <i>key</i> from underlying
94                 bundle or null if not found.
95         @throws IllegalArgumentException if <i>key</i> is null.
96      */
97
98     public String JavaDoc getString(String JavaDoc key) {
99         if(key == null){
100             String JavaDoc msg = "key may not have a null value";
101
102             throw new IllegalArgumentException JavaDoc(msg);
103         }
104
105         String JavaDoc str = null;
106
107         try{
108             str = bundle.getString(key);
109         }catch(MissingResourceException JavaDoc mre){
110             //bad: shouldn't mask an exception the following way:
111 // str = "[cannot find message associated with key '" + key + "' due to " + mre + "]";
112 // because it hides the fact that the String was missing
113 // from the calling code.
114 //good: could just throw the exception (or wrap it in another)
115 // but that would probably cause much havoc on existing
116 // code.
117 //better: consistent with container pattern to
118 // simply return null. Calling code can then do
119 // a null check.
120 str = null;
121         }
122
123         return str;
124     }
125
126     /**
127      * Get a string from the underlying resource bundle and format
128      * it with the given set of arguments.
129      *
130      * @param key
131      * @param args
132      */
133
134     public String JavaDoc getString(String JavaDoc key, Object JavaDoc[] args) {
135         String JavaDoc iString = null;
136         String JavaDoc value = getString(key);
137
138         // this check for the runtime exception is some pre 1.1.6
139 // VM's don't do an automatic toString() on the passed in
140 // objects and barf out
141
142         try {
143             // ensure the arguments are not null so pre 1.2 VM's don't barf
144 if(args==null){
145                 args = new Object JavaDoc[1];
146             }
147             
148             Object JavaDoc[] nonNullArgs = args;
149             for (int i=0; i<args.length; i++) {
150                 if (args[i] == null) {
151                     if (nonNullArgs==args){
152                         nonNullArgs=(Object JavaDoc[])args.clone();
153                     }
154                     nonNullArgs[i] = "null";
155                 }
156             }
157             if( value==null ) value=key;
158         MessageFormat JavaDoc mf = new MessageFormat JavaDoc(value);
159             mf.setLocale(locale);
160             iString = mf.format(nonNullArgs, new StringBuffer JavaDoc(), null).toString();
161         } catch (IllegalArgumentException JavaDoc iae) {
162             StringBuffer JavaDoc buf = new StringBuffer JavaDoc();
163             buf.append(value);
164             for (int i = 0; i < args.length; i++) {
165                 buf.append(" arg[" + i + "]=" + args[i]);
166             }
167             iString = buf.toString();
168         }
169         return iString;
170     }
171
172     /**
173      * Get a string from the underlying resource bundle and format it
174      * with the given object argument. This argument can of course be
175      * a String object.
176      *
177      * @param key
178      * @param arg
179      */
180
181     public String JavaDoc getString(String JavaDoc key, Object JavaDoc arg) {
182     Object JavaDoc[] args = new Object JavaDoc[] {arg};
183     return getString(key, args);
184     }
185
186     /**
187      * Get a string from the underlying resource bundle and format it
188      * with the given object arguments. These arguments can of course
189      * be String objects.
190      *
191      * @param key
192      * @param arg1
193      * @param arg2
194      */
195
196     public String JavaDoc getString(String JavaDoc key, Object JavaDoc arg1, Object JavaDoc arg2) {
197     Object JavaDoc[] args = new Object JavaDoc[] {arg1, arg2};
198     return getString(key, args);
199     }
200     
201     /**
202      * Get a string from the underlying resource bundle and format it
203      * with the given object arguments. These arguments can of course
204      * be String objects.
205      *
206      * @param key
207      * @param arg1
208      * @param arg2
209      * @param arg3
210      */
211
212     public String JavaDoc getString(String JavaDoc key, Object JavaDoc arg1, Object JavaDoc arg2,
213                 Object JavaDoc arg3) {
214     Object JavaDoc[] args = new Object JavaDoc[] {arg1, arg2, arg3};
215     return getString(key, args);
216     }
217
218     /**
219      * Get a string from the underlying resource bundle and format it
220      * with the given object arguments. These arguments can of course
221      * be String objects.
222      *
223      * @param key
224      * @param arg1
225      * @param arg2
226      * @param arg3
227      * @param arg4
228      */
229
230     public String JavaDoc getString(String JavaDoc key, Object JavaDoc arg1, Object JavaDoc arg2,
231                 Object JavaDoc arg3, Object JavaDoc arg4) {
232     Object JavaDoc[] args = new Object JavaDoc[] {arg1, arg2, arg3, arg4};
233     return getString(key, args);
234     }
235     // --------------------------------------------------------------
236 // STATIC SUPPORT METHODS
237 // --------------------------------------------------------------
238
239     private static Hashtable JavaDoc managers = new Hashtable JavaDoc();
240
241     /**
242      * Get the StringManager for a particular package. If a manager for
243      * a package already exists, it will be reused, else a new
244      * StringManager will be created and returned.
245      *
246      * @param packageName The package name
247      */
248     public synchronized static StringManager getManager(String JavaDoc packageName) {
249       StringManager mgr = (StringManager)managers.get(packageName);
250       if (mgr == null) {
251           mgr = new StringManager(packageName);
252           managers.put(packageName, mgr);
253       }
254       return mgr;
255     }
256
257     /**
258      * Get the StringManager for a particular package. If a manager for
259      * a package already exists, it will be reused, else a new
260      * StringManager will be created and returned.
261      *
262      * @param bundle The resource bundle
263      */
264     public synchronized static StringManager getManager(ResourceBundle JavaDoc bundle) {
265       return new StringManager( bundle );
266     }
267
268     /**
269      * Get the StringManager for a particular package and Locale. If a manager for
270      * a package already exists, it will be reused, else a new
271      * StringManager will be created for that Locale and returned.
272      *
273      * @param packageName The package name
274      * @param loc The locale
275      */
276
277    public synchronized static StringManager getManager(String JavaDoc packageName,Locale JavaDoc loc) {
278       StringManager mgr = (StringManager)managers.get(packageName+"_"+loc.toString());
279       if (mgr == null) {
280           mgr = new StringManager(packageName,loc);
281           managers.put(packageName+"_"+loc.toString(), mgr);
282       }
283       return mgr;
284     }
285
286 }
287
Popular Tags