00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 package cast.cdl;
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 public class WorkingMemoryEntry extends Ice.ObjectImpl
00024 {
00025 public WorkingMemoryEntry()
00026 {
00027 }
00028
00029 public WorkingMemoryEntry(String id, String type, int version, Ice.Object entry)
00030 {
00031 this.id = id;
00032 this.type = type;
00033 this.version = version;
00034 this.entry = entry;
00035 }
00036
00037 private static class __F implements Ice.ObjectFactory
00038 {
00039 public Ice.Object
00040 create(String type)
00041 {
00042 assert(type.equals(ice_staticId()));
00043 return new WorkingMemoryEntry();
00044 }
00045
00046 public void
00047 destroy()
00048 {
00049 }
00050 }
00051 private static Ice.ObjectFactory _factory = new __F();
00052
00053 public static Ice.ObjectFactory
00054 ice_factory()
00055 {
00056 return _factory;
00057 }
00058
00059 public static final String[] __ids =
00060 {
00061 "::Ice::Object",
00062 "::cast::cdl::WorkingMemoryEntry"
00063 };
00064
00065 public boolean
00066 ice_isA(String s)
00067 {
00068 return java.util.Arrays.binarySearch(__ids, s) >= 0;
00069 }
00070
00071 public boolean
00072 ice_isA(String s, Ice.Current __current)
00073 {
00074 return java.util.Arrays.binarySearch(__ids, s) >= 0;
00075 }
00076
00077 public String[]
00078 ice_ids()
00079 {
00080 return __ids;
00081 }
00082
00083 public String[]
00084 ice_ids(Ice.Current __current)
00085 {
00086 return __ids;
00087 }
00088
00089 public String
00090 ice_id()
00091 {
00092 return __ids[1];
00093 }
00094
00095 public String
00096 ice_id(Ice.Current __current)
00097 {
00098 return __ids[1];
00099 }
00100
00101 public static String
00102 ice_staticId()
00103 {
00104 return __ids[1];
00105 }
00106
00107 public void
00108 __write(IceInternal.BasicStream __os)
00109 {
00110 __os.writeTypeId(ice_staticId());
00111 __os.startWriteSlice();
00112 __os.writeString(id);
00113 __os.writeString(type);
00114 __os.writeInt(version);
00115 __os.writeObject(entry);
00116 __os.endWriteSlice();
00117 super.__write(__os);
00118 }
00119
00120 private class Patcher implements IceInternal.Patcher, Ice.ReadObjectCallback
00121 {
00122 public void
00123 patch(Ice.Object v)
00124 {
00125 try
00126 {
00127 entry = (Ice.Object)v;
00128 }
00129 catch(ClassCastException ex)
00130 {
00131 IceInternal.Ex.throwUOE(type(), v.ice_id());
00132 }
00133 }
00134
00135 public String
00136 type()
00137 {
00138 return "::Ice::Object";
00139 }
00140
00141 public void
00142 invoke(Ice.Object v)
00143 {
00144 patch(v);
00145 }
00146 }
00147
00148 public void
00149 __read(IceInternal.BasicStream __is, boolean __rid)
00150 {
00151 if(__rid)
00152 {
00153 __is.readTypeId();
00154 }
00155 __is.startReadSlice();
00156 id = __is.readString();
00157 type = __is.readString();
00158 version = __is.readInt();
00159 __is.readObject(new Patcher());
00160 __is.endReadSlice();
00161 super.__read(__is, true);
00162 }
00163
00164 public void
00165 __write(Ice.OutputStream __outS)
00166 {
00167 __outS.writeTypeId(ice_staticId());
00168 __outS.startSlice();
00169 __outS.writeString(id);
00170 __outS.writeString(type);
00171 __outS.writeInt(version);
00172 __outS.writeObject(entry);
00173 __outS.endSlice();
00174 super.__write(__outS);
00175 }
00176
00177 public void
00178 __read(Ice.InputStream __inS, boolean __rid)
00179 {
00180 if(__rid)
00181 {
00182 __inS.readTypeId();
00183 }
00184 __inS.startSlice();
00185 id = __inS.readString();
00186 type = __inS.readString();
00187 version = __inS.readInt();
00188 __inS.readObject(new Patcher());
00189 __inS.endSlice();
00190 super.__read(__inS, true);
00191 }
00192
00193 public String id;
00194
00195 public String type;
00196
00197 public int version;
00198
00199 public Ice.Object entry;
00200 }