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;
}
}
public virtual void endReadEncaps()
{
Debug.Assert(_readEncapsStack != null);
if(_buf.b.position() != _readEncapsStack.start + _readEncapsStack.sz)
{
if(_buf.b.position() + 1 != _readEncapsStack.start + _readEncapsStack.sz)
{
throw new Ice.EncapsulationException();
}
//
// Ice version < 3.3 had a bug where user exceptions with
// class members could be encoded with a trailing byte
// when dispatched with AMD. So we tolerate an extra byte
// in the encapsulation.
//
try
{
_buf.b.get();
}
catch(InvalidOperationException ex)
{
throw new Ice.UnmarshalOutOfBoundsException(ex);
}
}
ReadEncaps curr = _readEncapsStack;
_readEncapsStack = curr.next;
curr.next = _readEncapsCache;
_readEncapsCache = curr;
_readEncapsCache.reset();
}
private void initialize(Instance instance, bool unlimited)
{
instance_ = instance;
_buf = new Buffer(instance_.messageSizeMax());
_closure = null;
_unlimited = unlimited;
_readEncapsStack = null;
_writeEncapsStack = null;
_readEncapsCache = null;
_writeEncapsCache = null;
_traceSlicing = -1;
_sliceObjects = true;
_messageSizeMax = instance_.messageSizeMax(); // Cached for efficiency.
_startSeq = -1;
_objectList = null;
}
public virtual void clear()
{
if(_readEncapsStack != null)
{
Debug.Assert(_readEncapsStack.next == null);
_readEncapsStack.next = _readEncapsCache;
_readEncapsCache = _readEncapsStack;
_readEncapsStack = null;
_readEncapsCache.reset();
}
if(_writeEncapsStack != null)
{
Debug.Assert(_writeEncapsStack.next == null);
_writeEncapsStack.next = _writeEncapsCache;
_writeEncapsCache = _writeEncapsStack;
_writeEncapsStack = null;
_writeEncapsCache.reset();
}
_startSeq = -1;
if(_objectList != null)
{
_objectList.Clear();
}
_sliceObjects = true;
}
public virtual void swap(BasicStream other)
{
Debug.Assert(instance_ == other.instance_);
object tmpClosure = other._closure;
other._closure = _closure;
_closure = tmpClosure;
Buffer tmpBuf = other._buf;
other._buf = _buf;
_buf = tmpBuf;
ReadEncaps tmpRead = other._readEncapsStack;
other._readEncapsStack = _readEncapsStack;
_readEncapsStack = tmpRead;
tmpRead = other._readEncapsCache;
other._readEncapsCache = _readEncapsCache;
_readEncapsCache = tmpRead;
WriteEncaps tmpWrite = other._writeEncapsStack;
other._writeEncapsStack = _writeEncapsStack;
_writeEncapsStack = tmpWrite;
tmpWrite = other._writeEncapsCache;
other._writeEncapsCache = _writeEncapsCache;
_writeEncapsCache = tmpWrite;
int tmpReadSlice = other._readSlice;
other._readSlice = _readSlice;
_readSlice = tmpReadSlice;
int tmpWriteSlice = other._writeSlice;
other._writeSlice = _writeSlice;
_writeSlice = tmpWriteSlice;
int tmpStartSeq = other._startSeq;
other._startSeq = _startSeq;
_startSeq = tmpStartSeq;
int tmpMinSeqSize = other._minSeqSize;
other._minSeqSize = _minSeqSize;
_minSeqSize = tmpMinSeqSize;
ArrayList tmpObjectList = other._objectList;
other._objectList = _objectList;
_objectList = tmpObjectList;
bool tmpUnlimited = other._unlimited;
other._unlimited = _unlimited;
_unlimited = tmpUnlimited;
}
public virtual void startReadEncaps()
{
{
ReadEncaps curr = _readEncapsCache;
if(curr != null)
{
curr.reset();
_readEncapsCache = _readEncapsCache.next;
}
else
{
curr = new ReadEncaps();
}
curr.next = _readEncapsStack;
_readEncapsStack = curr;
}
_readEncapsStack.start = _buf.b.position();
//
// I don't use readSize() and writeSize() for
// encapsulations, because when creating an encapsulation,
// I must know in advance how many bytes the size
// information will require in the data stream. If I use
// an Int, it is always 4 bytes. For
// readSize()/writeSize(), it could be 1 or 5 bytes.
//
int sz = readInt();
if(sz < 6)
{
throw new Ice.UnmarshalOutOfBoundsException();
}
if(sz - 4 > _buf.b.remaining())
{
throw new Ice.UnmarshalOutOfBoundsException();
}
_readEncapsStack.sz = sz;
byte eMajor = readByte();
byte eMinor = readByte();
if(eMajor != Protocol.encodingMajor || eMinor > Protocol.encodingMinor)
{
Ice.UnsupportedEncodingException e = new Ice.UnsupportedEncodingException();
e.badMajor = eMajor < 0 ? eMajor + 256 : eMajor;
e.badMinor = eMinor < 0 ? eMinor + 256 : eMinor;
e.major = Protocol.encodingMajor;
e.minor = Protocol.encodingMinor;
throw e;
}
// _readEncapsStack.encodingMajor = eMajor; // Currently unused
// _readEncapsStack.encodingMinor = eMinor; // Currently unused
}
