001: /*
002: * Copyright 1999,2004 The Apache Software Foundation.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016:
017: package org.apache.naming;
018:
019: import java.text.MessageFormat;
020: import java.util.Hashtable;
021: import java.util.MissingResourceException;
022: import java.util.ResourceBundle;
023:
024: /**
025: * An internationalization / localization helper class which reduces
026: * the bother of handling ResourceBundles and takes care of the
027: * common cases of message formating which otherwise require the
028: * creation of Object arrays and such.
029: *
030: * <p>The StringManager operates on a package basis. One StringManager
031: * per package can be created and accessed via the getManager method
032: * call.
033: *
034: * <p>The StringManager will look for a ResourceBundle named by
035: * the package name given plus the suffix of "LocalStrings". In
036: * practice, this means that the localized information will be contained
037: * in a LocalStrings.properties file located in the package
038: * directory of the classpath.
039: *
040: * <p>Please see the documentation for java.util.ResourceBundle for
041: * more information.
042: *
043: * @author James Duncan Davidson [duncan@eng.sun.com]
044: * @author James Todd [gonzo@eng.sun.com]
045: */
046:
047: public class StringManager {
048:
049: /**
050: * The ResourceBundle for this StringManager.
051: */
052:
053: private ResourceBundle bundle;
054:
055: /**
056: * Creates a new StringManager for a given package. This is a
057: * private method and all access to it is arbitrated by the
058: * static getManager method call so that only one StringManager
059: * per package will be created.
060: *
061: * @param packageName Name of package to create StringManager for.
062: */
063:
064: private StringManager(String packageName) {
065: String bundleName = packageName + ".LocalStrings";
066: bundle = ResourceBundle.getBundle(bundleName);
067: }
068:
069: /**
070: * Get a string from the underlying resource bundle.
071: *
072: * @param key
073: */
074:
075: public String getString(String key) {
076: if (key == null) {
077: String msg = "key is null";
078:
079: throw new NullPointerException(msg);
080: }
081:
082: String str = null;
083:
084: try {
085: str = bundle.getString(key);
086: } catch (MissingResourceException mre) {
087: str = "Cannot find message associated with key '" + key
088: + "'";
089: }
090:
091: return str;
092: }
093:
094: /**
095: * Get a string from the underlying resource bundle and format
096: * it with the given set of arguments.
097: *
098: * @param key
099: * @param args
100: */
101:
102: public String getString(String key, Object[] args) {
103: String iString = null;
104: String value = getString(key);
105:
106: // this check for the runtime exception is some pre 1.1.6
107: // VM's don't do an automatic toString() on the passed in
108: // objects and barf out
109:
110: try {
111: // ensure the arguments are not null so pre 1.2 VM's don't barf
112: Object nonNullArgs[] = args;
113: for (int i = 0; i < args.length; i++) {
114: if (args[i] == null) {
115: if (nonNullArgs == args)
116: nonNullArgs = (Object[]) args.clone();
117: nonNullArgs[i] = "null";
118: }
119: }
120:
121: iString = MessageFormat.format(value, nonNullArgs);
122: } catch (IllegalArgumentException iae) {
123: StringBuffer buf = new StringBuffer();
124: buf.append(value);
125: for (int i = 0; i < args.length; i++) {
126: buf.append(" arg[" + i + "]=" + args[i]);
127: }
128: iString = buf.toString();
129: }
130: return iString;
131: }
132:
133: /**
134: * Get a string from the underlying resource bundle and format it
135: * with the given object argument. This argument can of course be
136: * a String object.
137: *
138: * @param key
139: * @param arg
140: */
141:
142: public String getString(String key, Object arg) {
143: Object[] args = new Object[] { arg };
144: return getString(key, args);
145: }
146:
147: /**
148: * Get a string from the underlying resource bundle and format it
149: * with the given object arguments. These arguments can of course
150: * be String objects.
151: *
152: * @param key
153: * @param arg1
154: * @param arg2
155: */
156:
157: public String getString(String key, Object arg1, Object arg2) {
158: Object[] args = new Object[] { arg1, arg2 };
159: return getString(key, args);
160: }
161:
162: /**
163: * Get a string from the underlying resource bundle and format it
164: * with the given object arguments. These arguments can of course
165: * be String objects.
166: *
167: * @param key
168: * @param arg1
169: * @param arg2
170: * @param arg3
171: */
172:
173: public String getString(String key, Object arg1, Object arg2,
174: Object arg3) {
175: Object[] args = new Object[] { arg1, arg2, arg3 };
176: return getString(key, args);
177: }
178:
179: /**
180: * Get a string from the underlying resource bundle and format it
181: * with the given object arguments. These arguments can of course
182: * be String objects.
183: *
184: * @param key
185: * @param arg1
186: * @param arg2
187: * @param arg3
188: * @param arg4
189: */
190:
191: public String getString(String key, Object arg1, Object arg2,
192: Object arg3, Object arg4) {
193: Object[] args = new Object[] { arg1, arg2, arg3, arg4 };
194: return getString(key, args);
195: }
196:
197: // --------------------------------------------------------------
198: // STATIC SUPPORT METHODS
199: // --------------------------------------------------------------
200:
201: private static Hashtable managers = new Hashtable();
202:
203: /**
204: * Get the StringManager for a particular package. If a manager for
205: * a package already exists, it will be reused, else a new
206: * StringManager will be created and returned.
207: *
208: * @param packageName
209: */
210:
211: public synchronized static StringManager getManager(
212: String packageName) {
213: StringManager mgr = (StringManager) managers.get(packageName);
214: if (mgr == null) {
215: mgr = new StringManager(packageName);
216: managers.put(packageName, mgr);
217: }
218: return mgr;
219: }
220: }
|