001    /* ActivationID.java -- the object activation identifier
002       Copyright (c) 1996, 1997, 1998, 1999, 2006 Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package java.rmi.activation;
040    
041    import java.io.IOException;
042    import java.io.ObjectInputStream;
043    import java.io.ObjectOutputStream;
044    import java.io.Serializable;
045    import java.rmi.Remote;
046    import java.rmi.RemoteException;
047    import java.rmi.server.UID;
048    
049    /**
050     * Denotes the object that can be activated over time. The instance of the
051     * ActivationID for the given object can be obtained in the following ways:
052     * <ul>
053     * <li>via {@link Activatable#register(ActivationDesc)}</li>
054     * <li>via Activatable constructor</li>
055     * <li>via Activatable.exportObject
056     * <li>
057     * </ul>
058     * An instance of the ActivationID has the {@link UID} as its component and
059     * hence is globally unique.
060     *
061     * @author Audrius Meskauskas (audriusa@bioinformatics.org) (from stub)
062     */
063    public class ActivationID
064        implements Serializable
065    {
066      /**
067       * Use SVUID for interoperability.
068       */
069      static final long serialVersionUID = - 4608673054848209235L;
070    
071      /**
072       * The activator.
073       */
074      transient Activator activator;
075    
076      /**
077       * The UID, making this instance unique.
078       */
079      transient UID uid;
080    
081      /**
082       * The activation group that has activated the object with this
083       * activation id. The field is filled in inside the group and is used
084       * to notify the group about the request to inactivated the object.
085       */
086      transient ActivationGroup group;
087    
088      /**
089       * Create a new instance with the given activator.
090       *
091       * @param an_activator tha activator that should activate the object.
092       */
093      public ActivationID(Activator an_activator)
094      {
095        activator = an_activator;
096        uid = new UID();
097      }
098    
099      /**
100       * Activate the object.
101       *
102       * @param force if true, always contact the group. Otherwise, the cached value
103       *          may be returned.
104       * @return the activated object
105       * @throws UnknownObjectException if the object is unknown
106       * @throws ActivationException if the activation has failed
107       * @throws RemoteException if the remote call has failed
108       */
109      public Remote activate(boolean force) throws ActivationException,
110          UnknownObjectException, RemoteException
111      {
112            try
113              {
114                return (Remote) activator.activate(this, force).get();
115              }
116            catch (IOException e)
117              {
118                ActivationException acex = new ActivationException("id "+uid, e);
119                throw acex;
120              }
121            catch (ClassNotFoundException e)
122              {
123                ActivationException acex = new ActivationException("id "+uid, e);
124                throw acex;
125              }
126      }
127    
128      /**
129       * Returns the hash code of the activator.
130       */
131      public int hashCode()
132      {
133        return uid == null ? 0 : uid.hashCode();
134      }
135    
136      /**
137       * Compares the activators for equality.
138       */
139      public boolean equals(Object obj)
140      {
141        if (obj instanceof ActivationID)
142          {
143            ActivationID that = (ActivationID) obj;
144            return eq(uid, that.uid);
145          }
146        else
147          return false;
148      }
149    
150      /**
151       * Read the object from the input stream.
152       *
153       * @param in the stream to read from
154       *
155       * @throws IOException if thrown by the stream
156       * @throws ClassNotFoundException
157       */
158      private void readObject(ObjectInputStream in) throws IOException,
159          ClassNotFoundException
160      {
161         uid = (UID) in.readObject();
162         activator = (Activator) in.readObject();
163      }
164    
165      /**
166       * Write the object to the output stream.
167       *
168       * @param out the stream to write int
169       * @throws IOException if thrown by the stream
170       * @throws ClassNotFoundException
171       */
172      private void writeObject(ObjectOutputStream out) throws IOException,
173          ClassNotFoundException
174      {
175        out.writeObject(uid);
176        out.writeObject(activator);
177      }
178    
179      /**
180       * Compare by .equals if both a and b are not null, compare directly if at
181       * least one of them is null.
182       */
183      static final boolean eq(Object a, Object b)
184      {
185        if (a == null || b == null)
186          return a == b;
187        else
188          return a.equals(b);
189      }
190    
191      /**
192       * Return the content based string representation.
193       */
194      public String toString()
195      {
196        return uid.toString();
197      }
198    
199    }