connectors/util/java/org/apache/tomcat/util/res/StringManager.java - tomcat55 - Git at Google

 /*
  *  Copyright 1999-2004 The Apache Software Foundation
  *
  *  Licensed 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$ $Date$
  *
  * @author James Duncan Davidson [duncan@eng.sun.com]
  * @author James Todd [gonzo@eng.sun.com]
  * @author Mel Martinez [mmartinez@g1440.com]
  * @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;
     }

 }
	/*
	* Copyright 1999-2004 The Apache Software Foundation
	*
	* Licensed 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$ $Date$
	*
	* @author James Duncan Davidson [duncan@eng.sun.com]
	* @author James Todd [gonzo@eng.sun.com]
	* @author Mel Martinez [mmartinez@g1440.com]
	* @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;
	}

	}