/*

 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

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

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.activation;

import java.util.Map;

import java.util.WeakHashMap;

/**

 * The CommandMap class provides an interface to a registry of

 * command objects available in the system.

 * Developers are expected to either use the CommandMap

 * implementation included with this package (MailcapCommandMap) or

 * develop their own. Note that some of the methods in this class are

 * abstract.

 *

 * @since 1.6

 */

public abstract class CommandMap {

    private static CommandMap defaultCommandMap = null;

    private static Map<ClassLoader,CommandMap> map =

                                new WeakHashMap<ClassLoader,CommandMap>();

    /**

     * Get the default CommandMap.

     *

     * <ul>

     * <li> In cases where a CommandMap instance has been previously set

     *      to some value (via <i>setDefaultCommandMap</i>)

     *  return the CommandMap.

     * <li>

     *  In cases where no CommandMap has been set, the CommandMap

     *       creates an instance of {@code MailcapCommandMap} and

     *       set that to the default, returning its value.

     *

     * </ul>

     *

     * @return the CommandMap

     */

    public static synchronized CommandMap getDefaultCommandMap() {

        if (defaultCommandMap != null)

            return defaultCommandMap;

        // fetch per-thread-context-class-loader default

        ClassLoader tccl = SecuritySupport.getContextClassLoader();

        CommandMap def = map.get(tccl);

        if (def == null) {

            def = new MailcapCommandMap();

            map.put(tccl, def);

        }

        return def;

    }

    /**

     * Set the default CommandMap. Reset the CommandMap to the default by

     * calling this method with {@code null}.

     *

     * @param commandMap The new default CommandMap.

     * @exception SecurityException if the caller doesn't have permission

     *                                  to change the default

     */

    public static synchronized void setDefaultCommandMap(CommandMap commandMap) {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            try {

                // if it's ok with the SecurityManager, it's ok with me...

                security.checkSetFactory();

            } catch (SecurityException ex) {

                // otherwise, we also allow it if this code and the

                // factory come from the same (non-system) class loader (e.g.,

                // the JAF classes were loaded with the applet classes).

                ClassLoader cl = CommandMap.class.getClassLoader();

                if (cl == null || cl.getParent() == null ||

                    cl != commandMap.getClass().getClassLoader()) {

                    throw ex;

                }

            }

        }

        // remove any per-thread-context-class-loader CommandMap

        map.remove(SecuritySupport.getContextClassLoader());

        defaultCommandMap = commandMap;

    }

    /**

     * Get the preferred command list from a MIME Type. The actual semantics

     * are determined by the implementation of the CommandMap.

     *

     * @param mimeType  the MIME type

     * @return the CommandInfo classes that represent the command Beans.

     */

    abstract public  CommandInfo[] getPreferredCommands(String mimeType);

    /**

     * Get the preferred command list from a MIME Type. The actual semantics

     * are determined by the implementation of the CommandMap. <p>

     *

     * The {@code DataSource} provides extra information, such as

     * the file name, that a CommandMap implementation may use to further

     * refine the list of commands that are returned.  The implementation

     * in this class simply calls the {@code getPreferredCommands}

     * method that ignores this argument.

     *

     * @param mimeType  the MIME type

     * @param ds        a DataSource for the data

     * @return the CommandInfo classes that represent the command Beans.

     * @since   1.6, JAF 1.1

     */

    public CommandInfo[] getPreferredCommands(String mimeType, DataSource ds) {

        return getPreferredCommands(mimeType);

    }

    /**

     * Get all the available commands for this type. This method

     * should return all the possible commands for this MIME type.

     *

     * @param mimeType  the MIME type

     * @return the CommandInfo objects representing all the commands.

     */

    abstract public CommandInfo[] getAllCommands(String mimeType);

    /**

     * Get all the available commands for this type. This method

     * should return all the possible commands for this MIME type. <p>

     *

     * The {@code DataSource} provides extra information, such as

     * the file name, that a CommandMap implementation may use to further

     * refine the list of commands that are returned.  The implementation

     * in this class simply calls the {@code getAllCommands}

     * method that ignores this argument.

     *

     * @param mimeType  the MIME type

     * @param ds        a DataSource for the data

     * @return the CommandInfo objects representing all the commands.

     * @since   1.6, JAF 1.1

     */

    public CommandInfo[] getAllCommands(String mimeType, DataSource ds) {

        return getAllCommands(mimeType);

    }

    /**

     * Get the default command corresponding to the MIME type.

     *

     * @param mimeType  the MIME type

     * @param cmdName   the command name

     * @return the CommandInfo corresponding to the command.

     */

    abstract public CommandInfo getCommand(String mimeType, String cmdName);

    /**

     * Get the default command corresponding to the MIME type. <p>

     *

     * The {@code DataSource} provides extra information, such as

     * the file name, that a CommandMap implementation may use to further

     * refine the command that is chosen.  The implementation

     * in this class simply calls the {@code getCommand}

     * method that ignores this argument.

     *

     * @param mimeType  the MIME type

     * @param cmdName   the command name

     * @param ds        a DataSource for the data

     * @return the CommandInfo corresponding to the command.

     * @since   1.6, JAF 1.1

     */

    public CommandInfo getCommand(String mimeType, String cmdName,

                                DataSource ds) {

        return getCommand(mimeType, cmdName);

    }

    /**

     * Locate a DataContentHandler that corresponds to the MIME type.

     * The mechanism and semantics for determining this are determined

     * by the implementation of the particular CommandMap.

     *

     * @param mimeType  the MIME type

     * @return          the DataContentHandler for the MIME type

     */

    abstract public DataContentHandler createDataContentHandler(String

                                                                mimeType);

    /**

     * Locate a DataContentHandler that corresponds to the MIME type.

     * The mechanism and semantics for determining this are determined

     * by the implementation of the particular CommandMap. <p>

     *

     * The {@code DataSource} provides extra information, such as

     * the file name, that a CommandMap implementation may use to further

     * refine the choice of DataContentHandler.  The implementation

     * in this class simply calls the {@code createDataContentHandler}

     * method that ignores this argument.

     *

     * @param mimeType  the MIME type

     * @param ds        a DataSource for the data

     * @return          the DataContentHandler for the MIME type

     * @since   1.6, JAF 1.1

     */

    public DataContentHandler createDataContentHandler(String mimeType,

                                DataSource ds) {

        return createDataContentHandler(mimeType);

    }

    /**

     * Get all the MIME types known to this command map.

     * If the command map doesn't support this operation,

     * null is returned.

     *

     * @return          array of MIME types as strings, or null if not supported

     * @since   1.6, JAF 1.1

     */

    public String[] getMimeTypes() {

        return null;

    }

}