Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils.i18n;

import org.openconcerto.utils.Log;

import org.openconcerto.utils.ReflectUtils;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.Value;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import java.util.ResourceBundle.Control;

import java.util.logging.Level;

import net.jcip.annotations.ThreadSafe;

/**

 * Allow to create a list of instances from classes and other files ending with a language tag.

 *

 * @author Sylvain

 * @param <T> type of instances.

 * @see #createInstances(String, Locale)

 */

@ThreadSafe

public class LocalizedInstances<T> {

    private final Class<T> clazz;

    private final Control cntrl;

    private String staticMethodName;

    public LocalizedInstances(Class<T> clazz, Control cntrl) {

        super();

        this.clazz = clazz;

        this.cntrl = cntrl;

        this.staticMethodName = null;

    }

    public final Class<T> getClassToUse() {

        return this.clazz;

    }

    public final Control getControl() {

        return this.cntrl;

    }

    public final Tuple2<Locale, List<T>> createInstances(final Locale locale) {

        return this.createInstances(this.getClassToUse().getName(), locale);

    }

    public final Tuple2<Locale, List<T>> createInstances(final String baseName, final Locale locale) {

        return createInstances(baseName, locale, this.getClassToUse());

    }

    /**

     * Create instances of the same language. For each candidate locale, this method first looks for

     * {@link #getInstance(Class) a class} and then for

     * {@link #createInstance(String, Locale, Class) other files}.

     *

     * @param baseName the base name of the classes, e.g. "org.acme.MyClass".

     * @param locale the desired locale, e.g. fr_FR.

     * @param cl the class to use as context for loading

     *        {@link Class#forName(String, boolean, ClassLoader) classes} and

     *        {@link Class#getResourceAsStream(String) resources}.

     * @return the used locale and the instances, e.g. if no classes ending in fr were found, this

     *         method will use the {@link Control#getFallbackLocale(String, Locale) fallback} and if

     *         this also doesn't exist, then the locale will be <code>null</code> and the list

     *         empty.

     */

    public final Tuple2<Locale, List<T>> createInstances(final String baseName, final Locale locale, final Class<?> cl) {

        final List<T> l = new ArrayList<T>();

        Locale localeRes = null;

        // test emptiness to not mix languages

        for (Locale targetLocale = locale; targetLocale != null && l.isEmpty(); targetLocale = this.cntrl.getFallbackLocale(baseName, targetLocale)) {

            localeRes = targetLocale;

            // e.g. "fr_FR", "fr"

            for (final Locale candidate : this.cntrl.getCandidateLocales(baseName, targetLocale)) {

                // e.g. org.acme.MyClass_fr

                final String bundleName = this.cntrl.toBundleName(baseName, candidate);

                // code first

                final Class<? extends T> subclazz = ReflectUtils.getSubclass(bundleName, this.clazz, cl.getClassLoader());

                if (subclazz != null) {

                    try {

                        final Value<? extends T> instance = this.getInstance(subclazz);

                        if (instance.hasValue())

                            l.add(instance.getValue());

                        else

                            Log.get().warning(subclazz + " exists but the constructor wasn't found");

                    } catch (Exception e) {

                        Log.get().log(Level.WARNING, "Couldn't create an instance using " + subclazz, e);

                    }

                }

                try {

                    final T newInstance = this.createInstance(bundleName, candidate, cl);

                    if (newInstance != null)

                        l.add(newInstance);

                } catch (IOException e) {

                    Log.get().log(Level.WARNING, "Couldn't create an instance using " + bundleName, e);

                }

            }

        }

        return Tuple2.create(localeRes, l);

    }

    /**

     * The no-arg static method to use.

     *

     * @param staticMethodName a static method name, <code>null</code> meaning the constructor.

     * @return this.

     * @see #getInstance(Class)

     */

    public final synchronized LocalizedInstances<T> setStaticMethodName(String staticMethodName) {

        this.staticMethodName = staticMethodName;

        return this;

    }

    public final synchronized String getStaticMethodName() {

        return this.staticMethodName;

    }

    /**

     * Get an instance of the passed class. In this implementation, if

     * {@link #getStaticMethodName()} isn't <code>null</code> then it is used, otherwise the no-arg

     * constructor is used.

     *

     * @param subclass the class to use.

     * @return an instance or {@link Value#getNone()} if the method or constructor doesn't exist.

     * @exception IllegalAccessException if the method or constructor is inaccessible.

     * @exception InstantiationException if the class that declares the constructor represents an

     *            abstract class.

     * @exception InvocationTargetException if the method or constructor throws an exception.

     */

    protected <U extends T> Value<U> getInstance(final Class<U> subclass) throws InstantiationException, IllegalAccessException, InvocationTargetException {

        final String staticMethodName = this.getStaticMethodName();

        try {

            if (staticMethodName != null) {

                final Method method = subclass.getMethod(staticMethodName);

                if (Modifier.isStatic(method.getModifiers()) && subclass.isAssignableFrom(method.getReturnType())) {

                    return Value.getSome(subclass.cast(method.invoke(null)));

                } else {

                    return Value.getNone();

                }

            } else {

                final Constructor<U> ctor = subclass.getConstructor();

                return Value.getSome(ctor.newInstance());

            }

        } catch (NoSuchMethodException e) {

            return Value.getNone();

        }

    }

    /**

     * Create an instance for the passed bundle and locale.

     *

     * @param bundleName the bundle.

     * @param candidate the locale.

     * @param cl the class to use as context.

     * @return a new instance using a resource at <code>bundleName</code>, or <code>null</code>.

     * @throws IOException if an error occur while reading the resource.

     * @see Control#toResourceName(String, String)

     */

    protected T createInstance(final String bundleName, final Locale candidate, final Class<?> cl) throws IOException {

        return null;

    }

}