/*

 * Copyright (C) 2010, Sasa Zivkov <sasa.zivkov@sap.com>

 * and other copyright owners as documented in the project's IP log.

 *

 * This program and the accompanying materials are made available

 * under the terms of the Eclipse Distribution License v1.0 which

 * accompanies this distribution, is reproduced below, and is

 * available at http://www.eclipse.org/org/documents/edl-v10.php

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 *

 * - Redistributions in binary form must reproduce the above

 *   copyright notice, this list of conditions and the following

 *   disclaimer in the documentation and/or other materials provided

 *   with the distribution.

 *

 * - Neither the name of the Eclipse Foundation, Inc. nor the

 *   names of its contributors may be used to endorse or promote

 *   products derived from this software without specific prior

 *   written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.eclipse.jgit.pgm.nls;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import org.eclipse.jgit.errors.TranslationBundleLoadingException;

import org.eclipse.jgit.errors.TranslationStringMissingException;

/**

 * Global cache of translation bundles.

 * <p>

 * Every translation bundle will be cached here when it gets loaded for the

 * first time from a thread. Another lookup for the same translation bundle

 * (same locale and type) from the same or a different thread will return the

 * cached one.

 * <p>

 * Note that NLS instances maintain per-thread Map of loaded translation

 * bundles. Once a thread accesses a translation bundle it will keep reference

 * to it and will not call {@link #lookupBundle(Locale, Class)} again for the

 * same translation bundle as long as its locale doesn't change.

 */

class GlobalBundleCache {

	private static final Map<Locale, Map<Class, TranslationBundle>> cachedBundles

		= new HashMap<Locale, Map<Class, TranslationBundle>>();

	/**

	 * Looks up for a translation bundle in the global cache. If found returns

	 * the cached bundle. If not found creates a new instance puts it into the

	 * cache and returns it.

	 *

	 * @param <T>

	 *            required bundle type

	 * @param locale

	 *            the preferred locale

	 * @param type

	 *            required bundle type

	 * @return an instance of the required bundle type

	 * @exception TranslationBundleLoadingException see {@link TranslationBundle#load(Locale)}

	 * @exception TranslationStringMissingException see {@link TranslationBundle#load(Locale)}

	 */

	static synchronized <T extends TranslationBundle> T lookupBundle(Locale locale, Class<T> type) {

		try {

			Map<Class, TranslationBundle> bundles = cachedBundles.get(locale);

			if (bundles == null) {

				bundles = new HashMap<Class, TranslationBundle>();

				cachedBundles.put(locale, bundles);

			}

			TranslationBundle bundle = bundles.get(type);

			if (bundle == null) {

				bundle = type.newInstance();

				bundle.load(locale);

				bundles.put(type, bundle);

			}

			return (T) bundle;

		} catch (InstantiationException e) {

			throw new Error(e);

		} catch (IllegalAccessException e) {

			throw new Error(e);

		}

	}

}

/*

 * Copyright (C) 2010, Sasa Zivkov <sasa.zivkov@sap.com>

 * and other copyright owners as documented in the project's IP log.

 *

 * This program and the accompanying materials are made available

 * under the terms of the Eclipse Distribution License v1.0 which

 * accompanies this distribution, is reproduced below, and is

 * available at http://www.eclipse.org/org/documents/edl-v10.php

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 *

 * - Redistributions in binary form must reproduce the above

 *   copyright notice, this list of conditions and the following

 *   disclaimer in the documentation and/or other materials provided

 *   with the distribution.

 *

 * - Neither the name of the Eclipse Foundation, Inc. nor the

 *   names of its contributors may be used to endorse or promote

 *   products derived from this software without specific prior

 *   written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.eclipse.jgit.pgm.nls;

import java.util.Locale;

import java.util.concurrent.ConcurrentHashMap;

import org.eclipse.jgit.errors.TranslationBundleLoadingException;

import org.eclipse.jgit.errors.TranslationStringMissingException;

/**

 * The purpose of this class is to provide NLS (National Language Support)

 * configurable per thread.

 *

 * <p>

 * The {@link #setLocale(Locale)} method is used to configure locale for the

 * calling thread. The locale setting is thread inheritable. This means that a

 * child thread will have the same locale setting as its creator thread until it

 * changes it explicitly.

 *

 * <p>

 * Example of usage:

 *

 * <pre>

 * NLS.setLocale(Locale.GERMAN);

 * TransportText t = NLS.getBundleFor(TransportText.class);

 * </pre>

 */

public class NLS {

	/** The root locale constant. It is defined here because the Locale.ROOT is not defined in Java 5 */

	public static final Locale ROOT_LOCALE = new Locale("", "", "");

	private static final InheritableThreadLocal<NLS> local = new InheritableThreadLocal<NLS>() {

		protected NLS initialValue() {

			return new NLS(Locale.getDefault());

		}

	};

	/**

	 * Sets the locale for the calling thread.

	 * <p>

	 * The {@link #getBundleFor(Class)} method will honor this setting if if it

	 * is supported by the provided resource bundle property files. Otherwise,

	 * it will use a fall back locale as described in the

	 * {@link TranslationBundle}

	 *

	 * @param locale

	 *            the preferred locale

	 */

	public static void setLocale(Locale locale) {

		local.set(new NLS(locale));

	}

	/**

	 * Sets the JVM default locale as the locale for the calling thread.

	 * <p>

	 * Semantically this is equivalent to <code>NLS.setLocale(Locale.getDefault())</code>.

	 */

	public static void useJVMDefaultLocale() {

		local.set(new NLS(Locale.getDefault()));

	}

	/**

	 * Returns an instance of the translation bundle of the required type. All

	 * public String fields of the bundle instance will get their values

	 * injected as described in the {@link TranslationBundle}.

	 *

	 * @param <T>

	 *            required bundle type

	 * @param type

	 *            required bundle type

	 * @return an instance of the required bundle type

	 * @exception TranslationBundleLoadingException see {@link TranslationBundleLoadingException}

	 * @exception TranslationStringMissingException see {@link TranslationStringMissingException}

	 */

	public static <T extends TranslationBundle> T getBundleFor(Class<T> type) {

		return local.get().get(type);

	}

	final private Locale locale;

	final private ConcurrentHashMap<Class, TranslationBundle> map = new ConcurrentHashMap<Class, TranslationBundle>();

	private NLS(Locale locale) {

		this.locale = locale;

	}

	@SuppressWarnings("unchecked")

	private <T extends TranslationBundle> T get(Class<T> type) {

		TranslationBundle bundle = map.get(type);

		if (bundle == null) {

			bundle = GlobalBundleCache.lookupBundle(locale, type);

			// There is a small opportunity for a race, which we may

			// lose. Accept defeat and return the winner's instance.

			TranslationBundle old = map.putIfAbsent(type, bundle);

			if (old != null)

				bundle = old;

		}

		return (T) bundle;

	}

}

/*

 * Copyright (C) 2010, Sasa Zivkov <sasa.zivkov@sap.com>

 * and other copyright owners as documented in the project's IP log.

 *

 * This program and the accompanying materials are made available

 * under the terms of the Eclipse Distribution License v1.0 which

 * accompanies this distribution, is reproduced below, and is

 * available at http://www.eclipse.org/org/documents/edl-v10.php

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 *

 * - Redistributions in binary form must reproduce the above

 *   copyright notice, this list of conditions and the following

 *   disclaimer in the documentation and/or other materials provided

 *   with the distribution.

 *

 * - Neither the name of the Eclipse Foundation, Inc. nor the

 *   names of its contributors may be used to endorse or promote

 *   products derived from this software without specific prior

 *   written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.eclipse.jgit.pgm.nls;

import java.lang.reflect.Field;

import java.util.Locale;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import org.eclipse.jgit.errors.TranslationBundleLoadingException;

import org.eclipse.jgit.errors.TranslationStringMissingException;

/**

 * Base class for all translation bundles that provides injection of translated

 * texts into public String fields.

 *

 * <p>

 * The usage pattern is shown with the following example. First define a new

 * translation bundle:

 *

 * <pre>

 * public class TransportText extends TranslationBundle {

 * 	public static TransportText get() {

 * 		return NLS.getBundleFor(TransportText.class);

 * 	}

 *

 * 	public String repositoryNotFound;

 *

 * 	public String transportError;

 * }

 * </pre>

 *

 * Second, define one or more resource bundle property files.

 *

 * <pre>

 * TransportText_en_US.properties:

 * 		repositoryNotFound=repository {0} not found

 * 		transportError=unknown error talking to {0}

 * TransportText_de.properties:

 * 		repositoryNotFound=repository {0} nicht gefunden

 * 		transportError=unbekannter Fehler während der Kommunikation mit {0}

 * ...

 * </pre>

 *

 * Then make use of it:

 *

 * <pre>

 * NLS.setLocale(Locale.GERMAN); // or skip this call to stick to the JVM default locale

 * ...

 * throw new TransportException(uri, TransportText.get().transportError);

 * </pre>

 *

 * The translated text is automatically injected into the public String fields

 * according to the locale set with {@link NLS#setLocale(Locale)}. However, the

 * {@link NLS#setLocale(Locale)} method defines only prefered locale which will

 * be honored only if it is supported by the provided resource bundle property

 * files. Basically, this class will use

 * {@link ResourceBundle#getBundle(String, Locale)} method to load a resource

 * bundle. See the documentation of this method for a detailed explanation of

 * resource bundle loading strategy. After a bundle is created the

 * {@link #effectiveLocale()} method can be used to determine whether the

 * bundle really corresponds to the requested locale or is a fallback.

 *

 * <p>

 * To load a String from a resource bundle property file this class uses the

 * {@link ResourceBundle#getString(String)}. This method can throw the

 * {@link MissingResourceException} and this class is not making any effort to

 * catch and/or translate this exception.

 *

 * <p>

 * To define a concrete translation bundle one has to:

 * <ul>

 * <li>extend this class

 * <li>define a public static get() method like in the example above

 * <li>define public static String fields for each text message

 * <li>make sure the translation bundle class provide public no arg constructor

 * <li>provide one or more resource bundle property files in the same package

 * where the translation bundle class resides

 * </ul>

 */

public abstract class TranslationBundle {

	private Locale effectiveLocale;

	private ResourceBundle resourceBundle;

	/**

	 * @return the locale locale used for loading the resource bundle from which

	 *         the field values were taken

	 */

	public Locale effectiveLocale() {

		return effectiveLocale;

	}

	/**

	 * @return the resource bundle on which this translation bundle is based

	 */

	public ResourceBundle resourceBundle() {

		return resourceBundle;

	}

	/**

	 * Injects locale specific text in all instance fields of this instance.

	 * Only public instance fields of type <code>String</code> are considered.

	 * <p>

	 * The name of this (sub)class plus the given <code>locale</code> parameter

	 * define the resource bundle to be loaded. In other words the

	 * <code>this.getClass().getName()</code> is used as the

	 * <code>baseName</code> parameter in the

	 * {@link ResourceBundle#getBundle(String, Locale)} parameter to load the

	 * resource bundle.

	 * <p>

	 *

	 * @param locale

	 *            defines the locale to be used when loading the resource bundle

	 * @exception TranslationBundleLoadingException see {@link TranslationBundleLoadingException}

	 * @exception TranslationStringMissingException see {@link TranslationStringMissingException}

	 */

	void load(Locale locale) throws TranslationBundleLoadingException {

		Class bundleClass = getClass();

		try {

			resourceBundle = ResourceBundle.getBundle(bundleClass.getName(), locale);

		} catch (MissingResourceException e) {

			throw new TranslationBundleLoadingException(bundleClass, locale, e);

		}

		this.effectiveLocale = resourceBundle.getLocale();

		for (Field field : bundleClass.getFields()) {

			if (field.getType().equals(String.class)) {

				try {

					String translatedText = resourceBundle.getString(field.getName());

					field.set(this, translatedText);

				} catch (MissingResourceException e) {

					throw new TranslationStringMissingException(bundleClass, locale, field.getName(), e);

				} catch (IllegalArgumentException e) {

					throw new Error(e);

				} catch (IllegalAccessException e) {

					throw new Error(e);

				}

			}

		}

	}

}