| GNU Classpath (0.95) | |
| Frames | No Frames |
1: /* ObjectImpl.java -- 2: Copyright (C) 2005, 2006 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.portable; 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.NVList; 47: import org.omg.CORBA.NamedValue; 48: import org.omg.CORBA.ORB; 49: import org.omg.CORBA.Policy; 50: import org.omg.CORBA.Request; 51: import org.omg.CORBA.SetOverrideType; 52: 53: /** 54: * The basic implementation of the CORBA Object. The most of the methods 55: * delegate the functionality to the {@link Delegate} that can be replaced 56: * by {@link #_set_delegate(Delegate)}. 57: * 58: * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) 59: */ 60: public abstract class ObjectImpl 61: implements org.omg.CORBA.Object 62: { 63: /** 64: * The delegate, responsible for the method implementations. 65: */ 66: transient Delegate delegate; 67: 68: /** 69: * Create a request to invoke the method of this object, specifying 70: * context list and the list of the expected exception. 71: * 72: * @param context a list of additional properties. 73: * @param operation the name of method to be invoked. 74: * @param parameters the method parameters. 75: * @param returns the container for tge method returned value. 76: * @param exceptions the list of the possible exceptions that the method 77: * can throw. 78: * @param ctx_list the list of the context strings that need to be 79: * resolved and send as a context instance. 80: * 81: * @return the created reaquest. 82: */ 83: public Request _create_request(Context context, String operation, 84: NVList parameters, NamedValue returns, 85: ExceptionList exceptions, ContextList ctx_list 86: ) 87: { 88: return delegate.create_request(this, context, operation, parameters, 89: returns, exceptions, ctx_list 90: ); 91: } 92: 93: /** 94: * Create a request to invoke the method of this object. 95: * 96: * @param context a list of additional properties. 97: * @param operation the name of method to be invoked. 98: * @param parameters the method parameters. 99: * @param returns the container for tge method returned value. 100: * 101: * @return the created reaquest. 102: */ 103: public Request _create_request(Context context, String operation, 104: NVList parameters, NamedValue returns 105: ) 106: { 107: return delegate.create_request(this, context, operation, parameters, returns); 108: } 109: 110: /** 111: * Duplicate the object reference. This does not make much sense for 112: * java platform and is just included for the sake of compliance with 113: * CORBA APIs. 114: * 115: * The method may return the object reference itself. 116: * 117: * @return as a rule, <code>this</code>. 118: */ 119: public org.omg.CORBA.Object _duplicate() 120: { 121: return delegate.duplicate(this); 122: } 123: 124: /** 125: * Get vendor specific delegate, responsible for the implemented 126: * functionality. 127: */ 128: public Delegate _get_delegate() 129: { 130: return delegate; 131: } 132: 133: /** 134: * Retrieve the domain managers for this object. 135: * 136: * @return the domain managers. 137: */ 138: public DomainManager[] _get_domain_managers() 139: { 140: return delegate.get_domain_managers(this); 141: } 142: 143: /** 144: * Get the <code>InterfaceDef</code> for this Object. 145: */ 146: public org.omg.CORBA.Object _get_interface_def() 147: { 148: return delegate.get_interface_def(this); 149: } 150: 151: /** 152: * Returns the {@link Policy}, applying to this object. 153: * 154: * @param a_policy_type a type of policy to be obtained. 155: * @return a corresponding Policy object. 156: * 157: * @throws BAD_PARAM if the policy of the given type is not 158: * associated with this object, or if it is not supported by this ORB. 159: */ 160: public Policy _get_policy(int a_policy_type) 161: { 162: return delegate.get_policy(this, a_policy_type); 163: } 164: 165: /** 166: * Get the array of interface repository ids, defining this object. 167: */ 168: public abstract String[] _ids(); 169: 170: /** 171: * Get the hashcode this object reference. The same hashcode still 172: * does not means that the references are the same. From the other 173: * side, two different references may still refer to the same CORBA 174: * object. The returned value must not change during the object 175: * lifetime. 176: * 177: * @param max the maximal value to return. 178: * 179: * @return the hashcode. 180: */ 181: public int _hash(int max) 182: { 183: return delegate.hash(this, max); 184: } 185: 186: /** 187: * Invoke the operation. 188: * 189: * @param output the stream, containing the written arguments. 190: * 191: * @return the stream, from where the input parameters could be read. 192: * 193: * @throws ApplicationException if the application throws an exception, 194: * defined as a part of its remote method definition. 195: * 196: * @throws RemarshalException if reading(remarshalling) fails. 197: */ 198: public InputStream _invoke(OutputStream output) 199: throws org.omg.CORBA.portable.ApplicationException, 200: org.omg.CORBA.portable.RemarshalException 201: { 202: return delegate.invoke(this, output); 203: } 204: 205: /** 206: * Check if this object can be referenced by the given repository id. 207: * 208: * @param idl_id the repository id. 209: * 210: * @return true if the passed parameter is a repository id of this 211: * CORBA object. 212: */ 213: public boolean _is_a(String idl_id) 214: { 215: return delegate.is_a(this, idl_id); 216: } 217: 218: /** 219: * Return true if the other object references are equivalent, so far as 220: * it is possible to determine this easily. 221: * 222: * @param other the other object reference. 223: * 224: * @return true if both references refer the same object, false 225: * if they probably can refer different objects. Uses direct 226: * comparison if the delegate has not been set. 227: */ 228: public boolean _is_equivalent(org.omg.CORBA.Object other) 229: { 230: return (delegate == null) ? this == other 231: : delegate.is_equivalent(this, other); 232: } 233: 234: /** 235: * Returns true if the object is local. 236: * 237: * @return false, always (following 1.4 specs). Override to get 238: * functionality. 239: */ 240: public boolean _is_local() 241: { 242: return delegate.is_local(this); 243: } 244: 245: /** 246: * Determines if the server object for this reference has already 247: * been destroyed. 248: * 249: * @return true if the object has been destroyed, false otherwise. 250: */ 251: public boolean _non_existent() 252: { 253: return delegate.non_existent(this); 254: } 255: 256: /** 257: * Provides the reference to ORB. 258: * 259: * @return the associated ORB. 260: */ 261: public ORB _orb() 262: { 263: return delegate.orb(this); 264: } 265: 266: /** 267: * Free resoureces, occupied by this reference. The object implementation 268: * is not notified, and the other references to the same object are not 269: * affected. 270: */ 271: public void _release() 272: { 273: delegate.release(this); 274: } 275: 276: /** 277: * Release the reply stream back to ORB after finishing reading the data 278: * from it. 279: * 280: * @param stream the stream, normally returned by {@link #_invoke} or 281: * {@link ApplicationException#getInputStream()}, can be null. 282: */ 283: public void _releaseReply(InputStream stream) 284: { 285: if (delegate != null) 286: delegate.releaseReply(this, stream); 287: } 288: 289: /** 290: * Create a request to invoke the method of this CORBA object. 291: * 292: * @param method the name of the method to invoke. 293: * 294: * @return the request. 295: */ 296: public Request _request(String method) 297: { 298: return delegate.request(this, method); 299: } 300: 301: /** 302: * Create a request to invoke the method of this CORBA object. 303: * 304: * @param method the name of the method to invoke. 305: * @param response_expected specifies if this is one way message or the 306: * response to the message is expected. 307: * 308: * @return the stream where the method arguments should be written. 309: */ 310: public org.omg.CORBA.portable.OutputStream _request(String method, 311: boolean response_expected 312: ) 313: { 314: return delegate.request(this, method, response_expected); 315: } 316: 317: /** 318: * This method is always called after invoking the operation on the 319: * local servant. 320: * 321: * The default method returns without action. 322: * 323: * @param servant the servant. 324: */ 325: public void _servant_postinvoke(ServantObject servant) 326: { 327: delegate.servant_postinvoke(this, servant); 328: } 329: 330: /** 331: * Returns a servant that should be used for this request. 332: * The servant can also be casted to the expected type, calling the 333: * required method directly. 334: * 335: * @param method the operation 336: * @param expected_type the expected type of the servant. 337: * 338: * This implementation always returns null; override for different 339: * behavior. 340: * 341: * @return the servant or null if the servant is not an expected type 342: * of the method is not supported, for example, due security reasons. 343: */ 344: public ServantObject _servant_preinvoke(String method, Class expected_type) 345: { 346: return delegate.servant_preinvoke(this, method, expected_type); 347: } 348: 349: /** 350: * Set the delegate, responsible for the implemented functionality. 351: * 352: * @param a_delegate a delegate, responsible for the implemented 353: * functionality. 354: */ 355: public void _set_delegate(Delegate a_delegate) 356: { 357: delegate = a_delegate; 358: } 359: 360: /** 361: * Returns a new object with the new policies either replacing or 362: * extending the current policies, depending on the second parameter. 363: * 364: * @param policies the policy additions or replacements. 365: * @param how either {@link SetOverrideType#SET_OVERRIDE} to override the 366: * current policies of {@link SetOverrideType#ADD_OVERRIDE} to replace 367: * them. 368: */ 369: public org.omg.CORBA.Object _set_policy_override(Policy[] policies, 370: SetOverrideType how 371: ) 372: { 373: return delegate.set_policy_override(this, policies, how); 374: } 375: 376: /** 377: * Check if this object is equal to another object. 378: * 379: * @param other the other object to compare. 380: * 381: * @return true if the objects are equal. 382: */ 383: public boolean equals(java.lang.Object other) 384: { 385: if (delegate == null) 386: return this == other; 387: else 388: return delegate.equals(this, other); 389: } 390: 391: /** 392: * Return the string representation of the passed object. 393: * 394: * @return the string representation. 395: */ 396: public String toString() 397: { 398: return delegate.toString(this); 399: }
| GNU Classpath (0.95) |