diff options
Diffstat (limited to 'java/src/Ice/ObjectImpl.java')
| -rw-r--r-- | java/src/Ice/ObjectImpl.java | 461 |
1 files changed, 461 insertions, 0 deletions
diff --git a/java/src/Ice/ObjectImpl.java b/java/src/Ice/ObjectImpl.java new file mode 100644 index 00000000000..10157983472 --- /dev/null +++ b/java/src/Ice/ObjectImpl.java @@ -0,0 +1,461 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +package Ice; + +/** + * Base class for all Slice classes. + **/ +public abstract class ObjectImpl implements Object, java.lang.Cloneable, java.io.Serializable +{ + /** + * Instantiates an Ice object. + **/ + public + ObjectImpl() + { + } + + /** + * Returns a copy of the object. The cloned object contains field-for-field copies + * of the state. + * + * @return The cloned object. + **/ + public java.lang.Object + clone() + { + java.lang.Object o = null; + try + { + o = super.clone(); + } + catch(java.lang.CloneNotSupportedException ex) + { + assert false; // Impossible + } + return o; + } + + /** + * @deprecated + **/ + public int + ice_hash() + { + return hashCode(); + } + + public final static String[] __ids = + { + "::Ice::Object" + }; + + /** + * Tests whether this object supports a specific Slice interface. + * + * @param s The type ID of the Slice interface to test against. + * @return The return value is <code>true</code> if <code>s</code> is + * <code>::Ice::Object</code>. + **/ + public boolean + ice_isA(String s) + { + return s.equals(__ids[0]); + } + + /** + * Tests whether this object supports a specific Slice interface. + * + * @param s The type ID of the Slice interface to test against. + * @param current The current object for the invocation. + * @return The return value is <code>true</code> if <code>s</code> is + * <code>::Ice::Object</code>. + **/ + public boolean + ice_isA(String s, Current current) + { + return s.equals(__ids[0]); + } + + public static DispatchStatus + ___ice_isA(Ice.Object __obj, IceInternal.Incoming __inS, Current __current) + { + IceInternal.BasicStream __is = __inS.is(); + __is.startReadEncaps(); + String __id = __is.readString(); + __is.endReadEncaps(); + boolean __ret = __obj.ice_isA(__id, __current); + IceInternal.BasicStream __os = __inS.os(); + __os.writeBool(__ret); + return DispatchStatus.DispatchOK; + } + + /** + * Tests whether this object can be reached. + **/ + public void + ice_ping() + { + // Nothing to do. + } + + /** + * Tests whether this object can be reached. + * + * @param current The current object for the invocation. + **/ + public void + ice_ping(Current current) + { + // Nothing to do. + } + + public static DispatchStatus + ___ice_ping(Ice.Object __obj, IceInternal.Incoming __inS, Current __current) + { + __inS.is().skipEmptyEncaps(); + __obj.ice_ping(__current); + return DispatchStatus.DispatchOK; + } + + /** + * Returns the Slice type IDs of the interfaces supported by this object. + * + * @return An array whose only element is <code>::Ice::Object</code>. + **/ + public String[] + ice_ids() + { + return __ids; + } + + /** + * Returns the Slice type IDs of the interfaces supported by this object. + * + * @param current The current object for the invocation. + * @return An array whose only element is <code>::Ice::Object</code>. + **/ + public String[] + ice_ids(Current current) + { + return __ids; + } + + public static DispatchStatus + ___ice_ids(Ice.Object __obj, IceInternal.Incoming __inS, Current __current) + { + __inS.is().skipEmptyEncaps(); + String[] __ret = __obj.ice_ids(__current); + IceInternal.BasicStream __os = __inS.os(); + __os.writeStringSeq(__ret); + return DispatchStatus.DispatchOK; + } + + /** + * Returns the Slice type ID of the most-derived interface supported by this object. + * + * @return The return value is always <code>::Ice::Object</code>. + **/ + public String + ice_id() + { + return __ids[0]; + } + + /** + * Returns the Slice type ID of the most-derived interface supported by this object. + * + * @param current The current object for the invocation. + * @return The return value is always {@link IceObject}. + **/ + public String + ice_id(Current current) + { + return __ids[0]; + } + + public static DispatchStatus + ___ice_id(Ice.Object __obj, IceInternal.Incoming __inS, Current __current) + { + __inS.is().skipEmptyEncaps(); + String __ret = __obj.ice_id(__current); + IceInternal.BasicStream __os = __inS.os(); + __os.writeString(__ret); + return DispatchStatus.DispatchOK; + } + + /** + * Returns the Slice type ID of the interface supported by this object. + * + * @return The return value is always ::Ice::Object. + **/ + public static String + ice_staticId() + { + return __ids[0]; + } + + /** + * Returns the Freeze metadata attributes for an operation. + * + * @param The name of the operation. + * @return The least significant bit indicates whether the operation is a read + * or write operation. If the bit is set, the operation is a write operation. + * The expression <code>ice_operationAttributes("op") & 0x1</code> is true if + * the operation has a <code>["freeze:write"]</code> metadata directive. + * <p> + * The second- and third least significant bit indicate the transactional mode + * of the operation. The expression <code>ice_operationAttributes("op") & 0x6 >> 1</code> + * indicates the transactional mode as follows: + * <dl> + * <dt>0</dt> + * <dd><code>["freeze:read:supports"]</code></dd> + * <dt>1</dt> + * <dd><code>["freeze:read:mandatory"]</code> or <code>["freeze:write:mandatory"]</code></dd> + * <dt>2</dt> + * <dd><code>["freeze:read:required"]</code> or <code>["freeze:write:required"]</code></dd> + * <dt>3</dt> + * <dd><code>["freeze:read:never"]</code></dd> + * </dl> + * + * @see Freeze.TransactionalEvictor + **/ + public int ice_operationAttributes(String operation) + { + return 0; + } + + /** + * The Ice run time invokes this method prior to marshaling an object's data members. This allows a subclass + * to override this method in order to validate its data members. This default implementation does nothing. + **/ + public void + ice_preMarshal() + { + } + + /** + * This Ice run time invokes this method vafter unmarshaling an object's data members. This allows a + * subclass to override this method in order to perform additional initialization. This default + * implementation does nothing. + **/ + public void + ice_postUnmarshal() + { + } + + private final static String[] __all = + { + "ice_id", + "ice_ids", + "ice_isA", + "ice_ping" + }; + + /** + * Dispatches an invocation to a servant. This method is used by dispatch interceptors to forward an invocation + * to a servant (or to another interceptor). + * + * @param request The details of the invocation. + * @param cb The callback object for asynchchronous dispatch. For synchronous dispatch, the callback object must + * be <code>null</code>. + * @return The dispatch status for the operation. + * + * @see DispatchInterceptor + * @see DispatchInterceptorAsyncCallback + * @see DispatchStatus + **/ + public DispatchStatus + ice_dispatch(Request request, DispatchInterceptorAsyncCallback cb) + { + if(request.isCollocated()) + { + return __collocDispatch((IceInternal.Direct)request); + } + else + { + IceInternal.Incoming in = (IceInternal.Incoming)request; + if(cb != null) + { + in.push(cb); + } + try + { + in.startOver(); // may raise ResponseSentException + return __dispatch(in, in.getCurrent()); + } + finally + { + if(cb != null) + { + in.pop(); + } + } + } + } + + /** + * Dispatches an invocation to a servant. This method is used by dispatch interceptors to forward an invocation + * to a servant (or to another interceptor). + * + * @param request The details of the invocation. + * @return The dispatch status for the operation. + * + * @see DispatchInterceptor + * @see DispatchStatus + **/ + public DispatchStatus + ice_dispatch(Request request) + { + return ice_dispatch(request, null); + } + + public DispatchStatus + __dispatch(IceInternal.Incoming in, Current current) + { + int pos = java.util.Arrays.binarySearch(__all, current.operation); + if(pos < 0) + { + throw new Ice.OperationNotExistException(current.id, current.facet, current.operation); + } + + switch(pos) + { + case 0: + { + return ___ice_id(this, in, current); + } + case 1: + { + return ___ice_ids(this, in, current); + } + case 2: + { + return ___ice_isA(this, in, current); + } + case 3: + { + return ___ice_ping(this, in, current); + } + } + + assert(false); + throw new Ice.OperationNotExistException(current.id, current.facet, current.operation); + } + + public DispatchStatus + __collocDispatch(IceInternal.Direct request) + { + return request.run(this); + } + + + public void + __write(IceInternal.BasicStream __os) + { + __os.writeTypeId(ice_staticId()); + __os.startWriteSlice(); + __os.writeSize(0); // For compatibility with the old AFM. + __os.endWriteSlice(); + } + + public void + __read(IceInternal.BasicStream __is, boolean __rid) + { + if(__rid) + { + __is.readTypeId(); + } + + __is.startReadSlice(); + + // For compatibility with the old AFM. + int sz = __is.readSize(); + if(sz != 0) + { + throw new MarshalException(); + } + + __is.endReadSlice(); + } + + public void + __write(Ice.OutputStream __outS) + { + __outS.writeTypeId(ice_staticId()); + __outS.startSlice(); + __outS.writeSize(0); // For compatibility with the old AFM. + __outS.endSlice(); + } + + public void + __read(Ice.InputStream __inS, boolean __rid) + { + if(__rid) + { + __inS.readTypeId(); + } + + __inS.startSlice(); + + // For compatibility with the old AFM. + int sz = __inS.readSize(); + if(sz != 0) + { + throw new MarshalException(); + } + + __inS.endSlice(); + } + + private static String + operationModeToString(OperationMode mode) + { + if(mode == Ice.OperationMode.Normal) + { + return "::Ice::Normal"; + } + if(mode == Ice.OperationMode.Nonmutating) + { + return "::Ice::Nonmutating"; + } + + if(mode == Ice.OperationMode.Idempotent) + { + return "::Ice::Idempotent"; + } + + return "???"; + } + + protected static void + __checkMode(OperationMode expected, OperationMode received) + { + if(expected != received) + { + if(expected == Ice.OperationMode.Idempotent + && received == Ice.OperationMode.Nonmutating) + { + // + // Fine: typically an old client still using the + // deprecated nonmutating keyword + // + } + else + { + Ice.MarshalException ex = new Ice.MarshalException(); + ex.reason = "unexpected operation mode. expected = " + + operationModeToString(expected) + " received = " + + operationModeToString(received); + throw ex; + } + } + } +} |