libjava/classpath/org/omg/CORBA/LocalObject.java

   1 /* LocalObject.java --
   2    Copyright (C) 2005 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package org.omg.CORBA;
  40
  41 import org.omg.CORBA.BAD_PARAM;
  42 import org.omg.CORBA.Context;
  43 import org.omg.CORBA.ContextList;
  44 import org.omg.CORBA.DomainManager;
  45 import org.omg.CORBA.ExceptionList;
  46 import org.omg.CORBA.NO_IMPLEMENT;
  47 import org.omg.CORBA.NVList;
  48 import org.omg.CORBA.NamedValue;
  49 import org.omg.CORBA.Policy;
  50 import org.omg.CORBA.Request;
  51 import org.omg.CORBA.SetOverrideType;
  52 import org.omg.CORBA.portable.ApplicationException;
  53 import org.omg.CORBA.portable.InputStream;
  54 import org.omg.CORBA.portable.OutputStream;
  55 import org.omg.CORBA.portable.RemarshalException;
  56 import org.omg.CORBA.portable.ServantObject;
  57
  58 import javax.rmi.CORBA.Util;
  59
  60 /**
  61  * An object, formally implementing the CORBA {@link Object}, but actually
  62  * handling all invocations locally.
  63  * Various calls to the remote object specific methods throw the
  64  * {@link NO_IMPLEMENT}. The explaining message for this exception is
  65  * specified in java API as <code>"This is a locally constrained object."</code>.
  66  * It is not possible to get a stringified reference of the local object, or
  67  * invoke a method using DII (by name via {@link Request} class).
  68  *
  69  * However narrowing and widening methods will work with local objects.
  70  *
  71  * @since 1.4
  72  *
  73  * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
  74  */
  75 public class LocalObject
  76   implements org.omg.CORBA.Object
  77 {
  78   /**
  79    * The explaining message for the exception, thrown in response to call
  80    * the method, not appropriate for the local object.
  81    */
  82   private static final String INAPPROPRIATE =
  83     "This is a locally constrained object.";
  84
  85   /**
  86    * This method is not appropriate for the local objects and just
  87    * throws an exception.
  88    *
  89    * @throws NO_IMPLEMENT, always.
  90    */
  91   public Request _create_request(Context context, String operation,
  92                                  NVList parameters, NamedValue returns
  93                                 )
  94   {
  95     throw new NO_IMPLEMENT(INAPPROPRIATE);
  96   }
  97
  98   /**
  99    * This method is not appropriate for the local objects and just
 100    * throws an exception.
 101    *
 102    * @throws NO_IMPLEMENT, always.
 103    */
 104   public Request _create_request(Context context, String operation,
 105                                  NVList parameters, NamedValue returns,
 106                                  ExceptionList exceptions, ContextList ctx_list
 107                                 )
 108   {
 109     throw new NO_IMPLEMENT(INAPPROPRIATE);
 110   }
 111
 112   /**
 113    * This method is not appropriate for the local objects and just
 114    * throws an exception.
 115    *
 116    * @throws NO_IMPLEMENT, always.
 117    */
 118   public org.omg.CORBA.Object _duplicate()
 119   {
 120     throw new NO_IMPLEMENT(INAPPROPRIATE);
 121   }
 122
 123   /**
 124    * This method is not appropriate for the local objects and just
 125    * throws an exception.
 126    *
 127    * @throws NO_IMPLEMENT, always.
 128    */
 129   public DomainManager[] _get_domain_managers()
 130   {
 131     throw new NO_IMPLEMENT(INAPPROPRIATE);
 132   }
 133
 134   /**
 135    * This method is not appropriate for the local objects and just
 136    * throws an exception.
 137    *
 138    * @throws NO_IMPLEMENT, always.
 139    */
 140   public org.omg.CORBA.Object _get_interface_def()
 141   {
 142     throw new NO_IMPLEMENT(INAPPROPRIATE);
 143   }
 144
 145   /**
 146    * This method is not appropriate for the local objects and just
 147    * throws an exception.
 148    *
 149    * @throws NO_IMPLEMENT, always.
 150    */
 151   public org.omg.CORBA.Object _get_interface()
 152   {
 153     throw new NO_IMPLEMENT(INAPPROPRIATE);
 154   }
 155
 156   /**
 157    * This method is not appropriate for the local objects and just
 158    * throws an exception.
 159    *
 160    * @throws NO_IMPLEMENT, always.
 161    */
 162   public Policy _get_policy(int a_policy_type)
 163                      throws BAD_PARAM
 164   {
 165     throw new NO_IMPLEMENT(INAPPROPRIATE);
 166   }
 167
 168   /**
 169    * {@inheritDoc}
 170    */
 171   public int _hash(int maximum)
 172   {
 173     return Math.abs(hashCode()) % maximum;
 174   }
 175
 176   /**
 177    * This method is not appropriate for the local objects and just
 178    * throws an exception.
 179    *
 180    * @throws NO_IMPLEMENT, always.
 181    */
 182   public boolean _is_a(String repositoryIdentifer)
 183   {
 184     throw new NO_IMPLEMENT(INAPPROPRIATE);
 185   }
 186
 187   /**
 188    * Determines if the object is equal to another object, so far as it is
 189    * possible to determine easily.
 190    *
 191    * @param other the other object.
 192    *
 193    * @return true if the pased object is not null and
 194    * java.lang.Object.equals(other) returns true. False otherwise.
 195    */
 196   public boolean _is_equivalent(org.omg.CORBA.Object other)
 197   {
 198     if (other != null)
 199       if (other.equals(this))
 200         return true;
 201
 202     return false;
 203   }
 204
 205   /**
 206    * Always returs false.
 207    *
 208    * @return false, always.
 209    */
 210   public boolean _non_existent()
 211   {
 212     return false;
 213   }
 214
 215   /**
 216    * This method is not appropriate for the local objects and just
 217    * throws an exception.
 218    *
 219    * @throws NO_IMPLEMENT, always.
 220    */
 221   public void _release()
 222   {
 223     throw new NO_IMPLEMENT(INAPPROPRIATE);
 224   }
 225
 226   /**
 227    * This method is not appropriate for the local objects and just
 228    * throws an exception.
 229    *
 230    * @specnote it is possible to implement a local handling of the _request(),
 231    * but the API clearly states that NO_IMPLEMENT
 232    * must be thrown instead.
 233    *
 234    * @throws NO_IMPLEMENT, always.
 235    */
 236   public Request _request(String operation)
 237   {
 238     throw new NO_IMPLEMENT(INAPPROPRIATE);
 239   }
 240
 241   /**
 242    * This method is not appropriate for the local objects and just
 243    * throws an exception.
 244    *
 245    * @throws NO_IMPLEMENT, always.
 246    */
 247   public org.omg.CORBA.Object _set_policy_override(Policy[] policies,
 248                                                    SetOverrideType how
 249                                                   )
 250   {
 251     throw new NO_IMPLEMENT(INAPPROPRIATE);
 252   }
 253
 254   /**
 255    * This method is called from <code>rmic</code> generated stubs if the
 256    * {@link Util#isLocal()}, called passing <code>this</code> as parameter,
 257    * returns true. If the method returns null, the requested method is then
 258    * invoked on <code>this</code>. Else it is invoked on the returned object,
 259    * casting it into the interface that the local object implements. In this
 260    * case, the generated stub also later calls
 261    * {@link _servant_postinvoke(ServantObject)}, passing that returned target
 262    * as parameter.
 263    *
 264    * @param operation the name of the method being invoked.
 265    * @param expectedType the interface that the returned servant
 266    * object must implement.
 267    *
 268    * @throws NO_IMPLEMENT always. If used, the method must be overridden.
 269    */
 270   public ServantObject _servant_preinvoke(String operation, Class expectedType)
 271   {
 272     throw new NO_IMPLEMENT(INAPPROPRIATE);
 273   }
 274
 275
 276   /**
 277    * This method is called from <code>rmic</code> generated stubs if the
 278    * {@link Util#isLocal()}, called passing <code>this</code> as parameter,
 279    * returns true, and the {@link #_servant_preinvoke} return non-null object.
 280    * The stub then invokes the requrested method on that returned object and
 281    * later calls _servant_postinvoke, passing that returned target as parameter.
 282    *
 283    * @param servant the object that has served as the invocation target for the
 284    * current operation.
 285    */
 286   public void _servant_postinvoke(ServantObject servant)
 287   {
 288   }
 289
 290   /**
 291    * Invokes the operation. This method takes the OutputStream that was previously
 292    * returned by a {@link _request()} and returns an InputStream which
 293    * contains the reply. Up till jdk 1.5 inclusive this method is marked as
 294    * unimplemented.
 295    *
 296    * @throws NO_IMPLEMENT always.
 297    */
 298   public InputStream _invoke(OutputStream output)
 299     throws ApplicationException, RemarshalException
 300   {
 301     throw new NO_IMPLEMENT(INAPPROPRIATE);
 302   }
 303
 304   /**
 305    * While it may look that this should return true, the jdk 1.5 API states
 306    * that it must throw NO_IMPLEMENT instead. The rmi stubs do not call this
 307    * method to check if the object is local; they call {@link Util#isLocal()}
 308    * instead (passing <code>this</code> as parameter).
 309    *
 310    * @return never.
 311    *
 312    * @throws NO_IMPLEMENT always.
 313    */
 314   public boolean _is_local()
 315   {
 316     throw new NO_IMPLEMENT(INAPPROPRIATE);
 317   }
 318
 319
 320   /**
 321    * This method is not appropriate for the local objects and just
 322    * throws an exception.
 323    *
 324    * @throws NO_IMPLEMENT, always.
 325    */
 326   public ORB _orb()
 327   {
 328     throw new NO_IMPLEMENT(INAPPROPRIATE);
 329   }
 330
 331   /**
 332    * This method is not appropriate for the local objects and just
 333    * throws an exception.
 334    *
 335    * @throws NO_IMPLEMENT, always.
 336    */
 337   public void _releaseReply(InputStream input)
 338   {
 339     throw new NO_IMPLEMENT(INAPPROPRIATE);
 340   }
 341
 342   /**
 343    * This method is not appropriate for the local objects and just
 344    * throws an exception.
 345    *
 346    * @throws NO_IMPLEMENT, always.
 347    */
 348   public OutputStream _request(String operation, boolean responseExpected)
 349   {
 350     throw new NO_IMPLEMENT(INAPPROPRIATE);
 351   }
 352
 353   /**
 354    * This method is not appropriate for the local objects and just
 355    * throws an exception.
 356    *
 357    * @throws NO_IMPLEMENT, always.
 358    */
 359   public boolean validate_connection()
 360   {
 361     throw new NO_IMPLEMENT(INAPPROPRIATE);
 362   }
 363 }