diff options
Diffstat (limited to 'java/src/Ice/ObjectImpl.java')
| -rw-r--r-- | java/src/Ice/ObjectImpl.java | 394 |
1 files changed, 394 insertions, 0 deletions
diff --git a/java/src/Ice/ObjectImpl.java b/java/src/Ice/ObjectImpl.java new file mode 100644 index 00000000000..b69302d7e7d --- /dev/null +++ b/java/src/Ice/ObjectImpl.java @@ -0,0 +1,394 @@ +// ********************************************************************** +// +// Copyright (c) 2001 +// Mutable Realms, Inc. +// Huntsville, AL, USA +// +// All Rights Reserved +// +// ********************************************************************** + +package Ice; + +public class ObjectImpl implements Object +{ + public + ObjectImpl() + { + } + + public boolean + equals(java.lang.Object rhs) + { + try + { + Object r = (Object)rhs; + return this == r; + } + catch(ClassCastException ex) + { + } + return false; + } + + public java.lang.Object + clone() + throws java.lang.CloneNotSupportedException + { + Object result = null; + + try + { + result = (Object)getClass().newInstance(); + ((ObjectImpl)result).ice_copyStateFrom(this); + } + catch(InstantiationException ex) + { + CloneNotSupportedException e = new CloneNotSupportedException(); + e.initCause(ex); + throw e; + } + catch(IllegalAccessException ex) + { + CloneNotSupportedException e = new CloneNotSupportedException(); + e.initCause(ex); + throw e; + } + + return result; + } + + protected final void + ice_cloneFacets(Object obj) + throws java.lang.CloneNotSupportedException + { + // + // Clone facets. + // + ObjectImpl impl = (ObjectImpl)obj; + synchronized(impl._activeFacetMap) + { + if(!impl._activeFacetMap.isEmpty()) + { + java.util.Iterator p = impl._activeFacetMap.entrySet().iterator(); + while(p.hasNext()) + { + java.util.Map.Entry e = (java.util.Map.Entry)p.next(); + Object facet = (Object)e.getValue(); + _activeFacetMap.put(e.getKey(), facet.clone()); + } + } + } + } + + protected void + ice_copyStateFrom(Object obj) + throws java.lang.CloneNotSupportedException + { + ice_cloneFacets(obj); + } + + public int + ice_hash() + { + return hashCode(); + } + + public static String[] __ids = + { + "::Ice::Object" + }; + + public boolean + ice_isA(String s, Current current) + { + return s.equals(__ids[0]); + } + + public static IceInternal.DispatchStatus + ___ice_isA(Ice.Object __obj, IceInternal.Incoming __in, Current __current) + { + IceInternal.BasicStream __is = __in.is(); + IceInternal.BasicStream __os = __in.os(); + String __id = __is.readString(); + boolean __ret = __obj.ice_isA(__id, __current); + __os.writeBool(__ret); + return IceInternal.DispatchStatus.DispatchOK; + } + + public void + ice_ping(Current current) + { + // Nothing to do. + } + + public static IceInternal.DispatchStatus + ___ice_ping(Ice.Object __obj, IceInternal.Incoming __in, Current __current) + { + __obj.ice_ping(__current); + return IceInternal.DispatchStatus.DispatchOK; + } + + public String[] + ice_ids(Current current) + { + return __ids; + } + + public static IceInternal.DispatchStatus + ___ice_ids(Ice.Object __obj, IceInternal.Incoming __in, Current __current) + { + IceInternal.BasicStream __os = __in.os(); + String[] __ret = __obj.ice_ids(__current); + __os.writeStringSeq(__ret); + return IceInternal.DispatchStatus.DispatchOK; + } + + public String + ice_id(Current current) + { + return __ids[0]; + } + + public static IceInternal.DispatchStatus + ___ice_id(Ice.Object __obj, IceInternal.Incoming __in, Current __current) + { + IceInternal.BasicStream __os = __in.os(); + String __ret = __obj.ice_id(__current); + __os.writeString(__ret); + return IceInternal.DispatchStatus.DispatchOK; + } + + public final String[] + ice_facets(Current current) + { + synchronized(_activeFacetMap) + { + java.util.Set keySet = _activeFacetMap.keySet(); + String[] v = new String[keySet.size()]; + keySet.toArray(v); + return v; + } + } + + public static IceInternal.DispatchStatus + ___ice_facets(Ice.Object __obj, IceInternal.Incoming __in, Current __current) + { + IceInternal.BasicStream __os = __in.os(); + String[] __ret = __obj.ice_facets(__current); + __os.writeStringSeq(__ret); + return IceInternal.DispatchStatus.DispatchOK; + } + + public static String + ice_staticId() + { + return __ids[0]; + } + + private static String[] __all = + { + "ice_facets", + "ice_id", + "ice_ids", + "ice_isA", + "ice_ping" + }; + + public IceInternal.DispatchStatus + __dispatch(IceInternal.Incoming in, Current current) + { + int pos = java.util.Arrays.binarySearch(__all, current.operation); + if(pos < 0) + { + return IceInternal.DispatchStatus.DispatchOperationNotExist; + } + + switch(pos) + { + case 0: + { + return ___ice_facets(this, in, current); + } + case 1: + { + return ___ice_id(this, in, current); + } + case 2: + { + return ___ice_ids(this, in, current); + } + case 3: + { + return ___ice_isA(this, in, current); + } + case 4: + { + return ___ice_ping(this, in, current); + } + } + + assert(false); + return IceInternal.DispatchStatus.DispatchOperationNotExist; + } + + public void + __write(IceInternal.BasicStream __os) + { + synchronized(_activeFacetMap) + { + final int sz = _activeFacetMap.size(); + __os.writeSize(sz); + + java.util.Set set = _activeFacetMap.keySet(); + String[] keys = new String[sz]; + set.toArray(keys); + for(int i = 0; i < sz; i++) + { + __os.writeString(keys[i]); + __os.writeObject((Object)_activeFacetMap.get(keys[i])); + } + } + } + + public void + __read(IceInternal.BasicStream __is) + { + synchronized(_activeFacetMap) + { + int sz = __is.readSize(); + + _activeFacetMap.clear(); + + while(sz-- > 0) + { + String key = __is.readString(); + Object value = __is.readObject("", null); + _activeFacetMap.put(key, value); + } + } + } + + public void + __marshal(Ice.Stream __os) + { + synchronized(_activeFacetMap) + { + final int sz = _activeFacetMap.size(); + + __os.startWriteDictionary("ice:facets", sz); + java.util.Set set = _activeFacetMap.keySet(); + String[] keys = new String[sz]; + set.toArray(keys); + for(int i = 0; i < sz; i++) + { + __os.startWriteDictionaryElement(); + __os.writeString("key", keys[i]); + __os.writeObject("value", (Object)_activeFacetMap.get(keys[i])); + __os.endWriteDictionaryElement(); + } + __os.endWriteDictionary(); + } + } + + public void + __unmarshal(Ice.Stream __is) + { + synchronized(_activeFacetMap) + { + final String facetsName = "ice:facets"; + final String keyName = "key"; + final String valueName = "value"; + + int sz = __is.startReadDictionary(facetsName); + + _activeFacetMap.clear(); + + while(sz-- > 0) + { + __is.startReadDictionaryElement(); + String key = __is.readString(keyName); + Object value = __is.readObject(valueName, "", null); + _activeFacetMap.put(key, value); + __is.endReadDictionaryElement(); + } + __is.endReadDictionary(); + } + } + + public final void + ice_marshal(String name, Ice.Stream stream) + { + stream.writeObject(name, this); + } + + public static Object + ice_unmarshal(String name, Ice.Stream stream) + { + return stream.readObject(name, "", null); + } + + public final void + ice_addFacet(Object facet, String name) + { + synchronized(_activeFacetMap) + { + _activeFacetMap.put(name, facet); + } + } + + public final void + ice_removeFacet(String name) + { + synchronized(_activeFacetMap) + { + _activeFacetMap.remove(name); + } + } + + public final void + ice_removeAllFacets() + { + synchronized(_activeFacetMap) + { + _activeFacetMap.clear(); + } + } + + public final Object + ice_findFacet(String name) + { + synchronized(_activeFacetMap) + { + return (Object)_activeFacetMap.get(name); + } + } + + public final Object + ice_findFacetPath(String[] path, int start) + { + int sz = path.length; + + if(start > sz) + { + return null; + } + + if(start == sz) + { + return this; + } + + Object f = ice_findFacet(path[start]); + if(f != null) + { + return f.ice_findFacetPath(path, start + 1); + } + else + { + return f; + } + } + + private java.util.HashMap _activeFacetMap = new java.util.HashMap(); +} |