001 /* LocalObject.java -- 002 Copyright (C) 2005, 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 org.omg.CORBA; 040 041 import org.omg.CORBA.BAD_PARAM; 042 import org.omg.CORBA.Context; 043 import org.omg.CORBA.ContextList; 044 import org.omg.CORBA.DomainManager; 045 import org.omg.CORBA.ExceptionList; 046 import org.omg.CORBA.NO_IMPLEMENT; 047 import org.omg.CORBA.NVList; 048 import org.omg.CORBA.NamedValue; 049 import org.omg.CORBA.Policy; 050 import org.omg.CORBA.Request; 051 import org.omg.CORBA.SetOverrideType; 052 import org.omg.CORBA.portable.ApplicationException; 053 import org.omg.CORBA.portable.InputStream; 054 import org.omg.CORBA.portable.OutputStream; 055 import org.omg.CORBA.portable.RemarshalException; 056 import org.omg.CORBA.portable.ServantObject; 057 058 import javax.rmi.CORBA.Util; 059 060 /** 061 * An object, formally implementing the CORBA {@link Object}, but actually 062 * handling all invocations locally. 063 * Various calls to the remote object specific methods throw the 064 * {@link NO_IMPLEMENT}. The explaining message for this exception is 065 * specified in java API as <code>"This is a locally constrained object."</code>. 066 * It is not possible to get a stringified reference of the local object, or 067 * invoke a method using DII (by name via {@link Request} class). 068 * 069 * However narrowing and widening methods will work with local objects. 070 * 071 * @since 1.4 072 * 073 * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) 074 */ 075 public class LocalObject 076 implements org.omg.CORBA.Object 077 { 078 /** 079 * The explaining message for the exception, thrown in response to call 080 * the method, not appropriate for the local object. 081 */ 082 private static final String INAPPROPRIATE = 083 "This is a locally constrained object."; 084 085 /** 086 * This method is not appropriate for the local objects and just 087 * throws an exception. 088 * 089 * @throws NO_IMPLEMENT, always. 090 */ 091 public Request _create_request(Context context, String operation, 092 NVList parameters, NamedValue returns 093 ) 094 { 095 throw new NO_IMPLEMENT(INAPPROPRIATE); 096 } 097 098 /** 099 * 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 @SuppressWarnings("unchecked") // Needed for API compatibility 271 public ServantObject _servant_preinvoke(String operation, Class expectedType) 272 { 273 throw new NO_IMPLEMENT(INAPPROPRIATE); 274 } 275 276 277 /** 278 * This method is called from <code>rmic</code> generated stubs if the 279 * {@link Util#isLocal}, called passing <code>this</code> as parameter, 280 * returns true, and the {@link #_servant_preinvoke} return non-null object. 281 * The stub then invokes the requrested method on that returned object and 282 * later calls _servant_postinvoke, passing that returned target as parameter. 283 * 284 * @param servant the object that has served as the invocation target for the 285 * current operation. 286 */ 287 public void _servant_postinvoke(ServantObject servant) 288 { 289 } 290 291 /** 292 * Invokes the operation. This method takes the OutputStream that was previously 293 * returned by a {@link #_request(String)} and returns an InputStream which 294 * contains the reply. Up till jdk 1.5 inclusive this method is marked as 295 * unimplemented. 296 * 297 * @throws NO_IMPLEMENT always. 298 */ 299 public InputStream _invoke(OutputStream output) 300 throws ApplicationException, RemarshalException 301 { 302 throw new NO_IMPLEMENT(INAPPROPRIATE); 303 } 304 305 /** 306 * While it may look that this should return true, the jdk 1.5 API states 307 * that it must throw NO_IMPLEMENT instead. The rmi stubs do not call this 308 * method to check if the object is local; they call {@link Util#isLocal} 309 * instead (passing <code>this</code> as parameter). 310 * 311 * @return never. 312 * 313 * @throws NO_IMPLEMENT always. 314 */ 315 public boolean _is_local() 316 { 317 throw new NO_IMPLEMENT(INAPPROPRIATE); 318 } 319 320 321 /** 322 * This method is not appropriate for the local objects and just 323 * throws an exception. 324 * 325 * @throws NO_IMPLEMENT, always. 326 */ 327 public ORB _orb() 328 { 329 throw new NO_IMPLEMENT(INAPPROPRIATE); 330 } 331 332 /** 333 * This method is not appropriate for the local objects and just 334 * throws an exception. 335 * 336 * @throws NO_IMPLEMENT, always. 337 */ 338 public void _releaseReply(InputStream input) 339 { 340 throw new NO_IMPLEMENT(INAPPROPRIATE); 341 } 342 343 /** 344 * This method is not appropriate for the local objects and just 345 * throws an exception. 346 * 347 * @throws NO_IMPLEMENT, always. 348 */ 349 public OutputStream _request(String operation, boolean responseExpected) 350 { 351 throw new NO_IMPLEMENT(INAPPROPRIATE); 352 } 353 354 /** 355 * This method is not appropriate for the local objects and just 356 * throws an exception. 357 * 358 * @throws NO_IMPLEMENT, always. 359 */ 360 public boolean validate_connection() 361 { 362 throw new NO_IMPLEMENT(INAPPROPRIATE); 363 } 364 }