public virtual void readObject(IPatcher patcher) { Ice.Object v = null; if(_readEncapsStack == null) // Lazy initialization { _readEncapsStack = _readEncapsCache; if(_readEncapsStack != null) { _readEncapsCache = _readEncapsCache.next; } else { _readEncapsStack = new ReadEncaps(); } } if(_readEncapsStack.patchMap == null) // Lazy initialization { _readEncapsStack.patchMap = new Hashtable(); _readEncapsStack.unmarshaledMap = new Hashtable(); _readEncapsStack.typeIdMap = new Hashtable(); } int index = readInt(); if(patcher != null) { if(index == 0) { patcher.patch(null); return; } if(index < 0) { int i = -index; IceUtilInternal.LinkedList patchlist = (IceUtilInternal.LinkedList)_readEncapsStack.patchMap[i]; if(patchlist == null) { // // We have no outstanding instances to be patched // for this index, so make a new entry in the // patch map. // patchlist = new IceUtilInternal.LinkedList(); _readEncapsStack.patchMap[i] = patchlist; } // // Append a patcher for this instance and see if we // can patch the instance. (The instance may have been // unmarshaled previously.) // patchlist.Add(patcher); patchReferences(null, i); return; } } if(index < 0) { throw new Ice.MarshalException("Invalid class instance index"); } string mostDerivedId = readTypeId(); string id = mostDerivedId; while(true) { // // If we slice all the way down to Ice::Object, we throw // because Ice::Object is abstract. // if(id == Ice.ObjectImpl.ice_staticId()) { Ice.NoObjectFactoryException ex = new Ice.NoObjectFactoryException(); ex.type = mostDerivedId; throw ex; } // // Try to find a factory registered for the specific // type. // Ice.ObjectFactory userFactory = instance_.servantFactoryManager().find(id); if(userFactory != null) { v = userFactory.create(id); } // // If that fails, invoke the default factory if one // has been registered. // if(v == null) { userFactory = instance_.servantFactoryManager().find(""); if(userFactory != null) { v = userFactory.create(id); } } // // Last chance: check whether the class is // non-abstract and dynamically instantiate it using // reflection. // if(v == null) { userFactory = loadObjectFactory(id); if(userFactory != null) { v = userFactory.create(id); } } if(v == null) { if(_sliceObjects) { // // Performance sensitive, so we use lazy // initialization for tracing. // if(_traceSlicing == -1) { _traceSlicing = instance_.traceLevels().slicing; _slicingCat = instance_.traceLevels().slicingCat; } if(_traceSlicing > 0) { TraceUtil.traceSlicing("class", id, _slicingCat, instance_.initializationData().logger); } skipSlice(); // Slice off this derived part -- we don't understand it. id = readTypeId(); // Read next id for next iteration. continue; } else { Ice.NoObjectFactoryException ex = new Ice.NoObjectFactoryException(); ex.type = id; throw ex; } } int i = index; _readEncapsStack.unmarshaledMap[i] = v; // // Record each object instance so that // readPendingObjects can invoke ice_postUnmarshal // after all objects have been unmarshaled. // if(_objectList == null) { _objectList = new ArrayList(); } _objectList.Add(v); v.read__(this, false); patchReferences(i, null); return; } }