Added: tomcat/sandbox/tomcat-lite/tomcat-coyote/org/apache/tomcat/util/res/StringManager.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/tomcat-coyote/org/apache/tomcat/util/res/StringManager.java?rev=640706&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/tomcat-coyote/org/apache/tomcat/util/res/StringManager.java (added) +++ tomcat/sandbox/tomcat-lite/tomcat-coyote/org/apache/tomcat/util/res/StringManager.java Mon Mar 24 23:01:43 2008 @@ -0,0 +1,286 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.tomcat.util.res; + +import java.text.MessageFormat; +import java.util.Hashtable; +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * An internationalization / localization helper class which reduces + * the bother of handling ResourceBundles and takes care of the + * common cases of message formating which otherwise require the + * creation of Object arrays and such. + * + * <p>The StringManager operates on a package basis. One StringManager + * per package can be created and accessed via the getManager method + * call. + * + * <p>The StringManager will look for a ResourceBundle named by + * the package name given plus the suffix of "LocalStrings". In + * practice, this means that the localized information will be contained + * in a LocalStrings.properties file located in the package + * directory of the classpath. + * + * <p>Please see the documentation for java.util.ResourceBundle for + * more information. + * + * @version $Revision: 467222 $ $Date: 2006-10-23 20:17:11 -0700 (Mon, 23 Oct 2006) $ + * + * @author James Duncan Davidson [EMAIL PROTECTED] + * @author James Todd [EMAIL PROTECTED] + * @author Mel Martinez [EMAIL PROTECTED] + * @see java.util.ResourceBundle + */ + +public class StringManager { + + /** + * The ResourceBundle for this StringManager. + */ + + private ResourceBundle bundle; + private Locale locale; + + /** + * Creates a new StringManager for a given package. This is a + * private method and all access to it is arbitrated by the + * static getManager method call so that only one StringManager + * per package will be created. + * + * @param packageName Name of package to create StringManager for. + */ + + private StringManager(String packageName) { + this( packageName, Locale.getDefault() ); + } + + private StringManager(String packageName, Locale loc) { + String bundleName = packageName + ".LocalStrings"; + bundle = ResourceBundle.getBundle(bundleName, loc); + // Get the actual locale, which may be different from the requested one + locale = bundle.getLocale(); + } + + private StringManager(ResourceBundle bundle ) + { + this.bundle=bundle; + locale = bundle.getLocale(); + } + + /** + Get a string from the underlying resource bundle or return + null if the String is not found. + + @param key to desired resource String + @return resource String matching <i>key</i> from underlying + bundle or null if not found. + @throws IllegalArgumentException if <i>key</i> is null. + */ + + public String getString(String key) { + if(key == null){ + String msg = "key may not have a null value"; + + throw new IllegalArgumentException(msg); + } + + String str = null; + + try{ + str = bundle.getString(key); + }catch(MissingResourceException mre){ + //bad: shouldn't mask an exception the following way: + // str = "[cannot find message associated with key '" + key + "' due to " + mre + "]"; + // because it hides the fact that the String was missing + // from the calling code. + //good: could just throw the exception (or wrap it in another) + // but that would probably cause much havoc on existing + // code. + //better: consistent with container pattern to + // simply return null. Calling code can then do + // a null check. + str = null; + } + + return str; + } + + /** + * Get a string from the underlying resource bundle and format + * it with the given set of arguments. + * + * @param key + * @param args + */ + + public String getString(String key, Object[] args) { + String iString = null; + String value = getString(key); + + // this check for the runtime exception is some pre 1.1.6 + // VM's don't do an automatic toString() on the passed in + // objects and barf out + + try { + // ensure the arguments are not null so pre 1.2 VM's don't barf + if(args==null){ + args = new Object[1]; + } + + Object[] nonNullArgs = args; + for (int i=0; i<args.length; i++) { + if (args[i] == null) { + if (nonNullArgs==args){ + nonNullArgs=(Object[])args.clone(); + } + nonNullArgs[i] = "null"; + } + } + if( value==null ) value=key; + MessageFormat mf = new MessageFormat(value); + mf.setLocale(locale); + iString = mf.format(nonNullArgs, new StringBuffer(), null).toString(); + } catch (IllegalArgumentException iae) { + StringBuffer buf = new StringBuffer(); + buf.append(value); + for (int i = 0; i < args.length; i++) { + buf.append(" arg[" + i + "]=" + args[i]); + } + iString = buf.toString(); + } + return iString; + } + + /** + * Get a string from the underlying resource bundle and format it + * with the given object argument. This argument can of course be + * a String object. + * + * @param key + * @param arg + */ + + public String getString(String key, Object arg) { + Object[] args = new Object[] {arg}; + return getString(key, args); + } + + /** + * Get a string from the underlying resource bundle and format it + * with the given object arguments. These arguments can of course + * be String objects. + * + * @param key + * @param arg1 + * @param arg2 + */ + + public String getString(String key, Object arg1, Object arg2) { + Object[] args = new Object[] {arg1, arg2}; + return getString(key, args); + } + + /** + * Get a string from the underlying resource bundle and format it + * with the given object arguments. These arguments can of course + * be String objects. + * + * @param key + * @param arg1 + * @param arg2 + * @param arg3 + */ + + public String getString(String key, Object arg1, Object arg2, + Object arg3) { + Object[] args = new Object[] {arg1, arg2, arg3}; + return getString(key, args); + } + + /** + * Get a string from the underlying resource bundle and format it + * with the given object arguments. These arguments can of course + * be String objects. + * + * @param key + * @param arg1 + * @param arg2 + * @param arg3 + * @param arg4 + */ + + public String getString(String key, Object arg1, Object arg2, + Object arg3, Object arg4) { + Object[] args = new Object[] {arg1, arg2, arg3, arg4}; + return getString(key, args); + } + // -------------------------------------------------------------- + // STATIC SUPPORT METHODS + // -------------------------------------------------------------- + + private static Hashtable managers = new Hashtable(); + + /** + * Get the StringManager for a particular package. If a manager for + * a package already exists, it will be reused, else a new + * StringManager will be created and returned. + * + * @param packageName The package name + */ + public synchronized static StringManager getManager(String packageName) { + StringManager mgr = (StringManager)managers.get(packageName); + if (mgr == null) { + mgr = new StringManager(packageName); + managers.put(packageName, mgr); + } + return mgr; + } + + /** + * Get the StringManager for a particular package. If a manager for + * a package already exists, it will be reused, else a new + * StringManager will be created and returned. + * + * @param bundle The resource bundle + */ + public synchronized static StringManager getManager(ResourceBundle bundle) { + return new StringManager( bundle ); + } + + /** + * Get the StringManager for a particular package and Locale. If a manager for + * a package already exists, it will be reused, else a new + * StringManager will be created for that Locale and returned. + * + * @param packageName The package name + * @param loc The locale + */ + + public synchronized static StringManager getManager(String packageName,Locale loc) { + StringManager mgr = (StringManager)managers.get(packageName+"_"+loc.toString()); + if (mgr == null) { + mgr = new StringManager(packageName,loc); + managers.put(packageName+"_"+loc.toString(), mgr); + } + return mgr; + } + +}
--------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED]
