1 /*

     2  * Copyright 1997-1999 Sun Microsystems, Inc.  All Rights Reserved.

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

     4  *

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

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

     7  * published by the Free Software Foundation.  Sun designates this

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

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.activation;

    27 

    28 import java.io.*;

    29 import java.beans.Beans;

    30 

    31 /**

    32  * The CommandInfo class is used by CommandMap implementations to

    33  * describe the results of command requests. It provides the requestor

    34  * with both the verb requested, as well as an instance of the

    35  * bean. There is also a method that will return the name of the

    36  * class that implements the command but <i>it is not guaranteed to

    37  * return a valid value</i>. The reason for this is to allow CommandMap

    38  * implmentations that subclass CommandInfo to provide special

    39  * behavior. For example a CommandMap could dynamically generate

    40  * JavaBeans. In this case, it might not be possible to create an

    41  * object with all the correct state information solely from the class

    42  * name.

    43  *

    44  * @since 1.6

    45  */

    46 

    47 public class CommandInfo {

    48     private String verb;

    49     private String className;

    50 

    51     /**

    52      * The Constructor for CommandInfo.

    53      * @param verb The command verb this CommandInfo decribes.

    54      * @param className The command's fully qualified class name.

    55      */

    56     public CommandInfo(String verb, String className) {

    57         this.verb = verb;

    58         this.className = className;

    59     }

    60 

    61     /**

    62      * Return the command verb.

    63      *

    64      * @return the command verb.

    65      */

    66     public String getCommandName() {

    67         return verb;

    68     }

    69 

    70     /**

    71      * Return the command's class name. <i>This method MAY return null in

    72      * cases where a CommandMap subclassed CommandInfo for its

    73      * own purposes.</i> In other words, it might not be possible to

    74      * create the correct state in the command by merely knowing

    75      * its class name. <b>DO NOT DEPEND ON THIS METHOD RETURNING

    76      * A VALID VALUE!</b>

    77      *

    78      * @return The class name of the command, or <i>null</i>

    79      */

    80     public String getCommandClass() {

    81         return className;

    82     }

    83 

    84     /**

    85      * Return the instantiated JavaBean component.

    86      * <p>

    87      * Begin by instantiating the component with

    88      * <code>Beans.instantiate()</code>.

    89      * <p>

    90      * If the bean implements the <code>javax.activation.CommandObject</code>

    91      * interface, call its <code>setCommandContext</code> method.

    92      * <p>

    93      * If the DataHandler parameter is null, then the bean is

    94      * instantiated with no data. NOTE: this may be useful

    95      * if for some reason the DataHandler that is passed in

    96      * throws IOExceptions when this method attempts to

    97      * access its InputStream. It will allow the caller to

    98      * retrieve a reference to the bean if it can be

    99      * instantiated.

   100      * <p>

   101      * If the bean does NOT implement the CommandObject interface,

   102      * this method will check if it implements the

   103      * java.io.Externalizable interface. If it does, the bean's

   104      * readExternal method will be called if an InputStream

   105      * can be acquired from the DataHandler.<p>

   106      *

   107      * @param dh        The DataHandler that describes the data to be

   108      *                  passed to the command.

   109      * @param loader    The ClassLoader to be used to instantiate the bean.

   110      * @return The bean

   111      * @see java.beans.Beans#instantiate

   112      * @see javax.activation.CommandObject

   113      */

   114     public Object getCommandObject(DataHandler dh, ClassLoader loader)

   115                         throws IOException, ClassNotFoundException {

   116         Object new_bean = null;

   117 

   118         // try to instantiate the bean

   119         new_bean = java.beans.Beans.instantiate(loader, className);

   120 

   121         // if we got one and it is a CommandObject

   122         if (new_bean != null) {

   123             if (new_bean instanceof CommandObject) {

   124                 ((CommandObject)new_bean).setCommandContext(verb, dh);

   125             } else if (new_bean instanceof Externalizable) {

   126                 if (dh != null) {

   127                     InputStream is = dh.getInputStream();

   128                     if (is != null) {

   129                         ((Externalizable)new_bean).readExternal(

   130                                                new ObjectInputStream(is));

   131                     }

   132                 }

   133             }

   134         }

   135 

   136         return new_bean;

   137     }

   138 }