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 }