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;
}
}