internal EncapsDecoder10(InputStream stream, Encaps encaps, bool sliceValues, ValueFactoryManager f,
ClassResolver cr)
: base(stream, encaps, sliceValues, f, cr)
{
_sliceType = SliceType.NoSlice;
}
private int _valueIdIndex; // The ID of the next instance to unmarshal.
#endregion Fields
#region Constructors
internal EncapsDecoder11(InputStream stream, Encaps encaps, bool sliceValues, ValueFactoryManager f,
ClassResolver cr, CompactIdResolver r)
: base(stream, encaps, sliceValues, f, cr)
{
_compactIdResolver = r;
_current = null;
_valueIdIndex = 1;
}
internal EncapsDecoder(InputStream stream, Encaps encaps, bool sliceValues, ValueFactoryManager f,
ClassResolver cr)
{
_stream = stream;
_encaps = encaps;
_sliceValues = sliceValues;
_valueFactoryManager = f;
_classResolver = cr;
_typeIdIndex = 0;
_unmarshaledMap = new Dictionary<int, Ice.Object>();
}
/// <summary>
/// Ends the previous encapsulation.
/// </summary>
public void endEncapsulation()
{
Debug.Assert(_encapsStack != null);
if(!_encapsStack.encoding_1_0)
{
skipOptionals();
if(_buf.b.position() != _encapsStack.start + _encapsStack.sz)
{
throw new EncapsulationException();
}
}
else if(_buf.b.position() != _encapsStack.start + _encapsStack.sz)
{
if(_buf.b.position() + 1 != _encapsStack.start + _encapsStack.sz)
{
throw new 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 UnmarshalOutOfBoundsException(ex);
}
}
Encaps curr = _encapsStack;
_encapsStack = curr.next;
curr.next = _encapsCache;
_encapsCache = curr;
_encapsCache.reset();
}
/// <summary>
/// Releases any data retained by encapsulations. Internally calls clear().
/// </summary>
public void clear()
{
if(_encapsStack != null)
{
Debug.Assert(_encapsStack.next == null);
_encapsStack.next = _encapsCache;
_encapsCache = _encapsStack;
_encapsStack = null;
_encapsCache.reset();
}
_startSeq = -1;
_sliceValues = true;
}
private void resetEncapsulation()
{
_encapsStack = null;
}
private void initialize(EncodingVersion encoding)
{
instance_ = null;
_encoding = encoding;
_encapsStack = null;
_encapsCache = null;
_traceSlicing = false;
_closure = null;
_sliceValues = true;
_startSeq = -1;
_minSeqSize = 0;
}
private void initEncaps()
{
if(_encapsStack == null) // Lazy initialization
{
_encapsStack = _encapsCache;
if(_encapsStack != null)
{
_encapsCache = _encapsCache.next;
}
else
{
_encapsStack = new Encaps();
}
_encapsStack.setEncoding(_encoding);
_encapsStack.sz = _buf.b.limit();
}
if(_encapsStack.decoder == null) // Lazy initialization.
{
if(_encapsStack.encoding_1_0)
{
_encapsStack.decoder = new EncapsDecoder10(this, _encapsStack, _sliceValues, _valueFactoryManager,
_classResolver);
}
else
{
_encapsStack.decoder = new EncapsDecoder11(this, _encapsStack, _sliceValues, _valueFactoryManager,
_classResolver, _compactIdResolver);
}
}
}
/// <summary>
/// Reads the start of an encapsulation.
/// </summary>
/// <returns>The encapsulation encoding version.</returns>
public EncodingVersion startEncapsulation()
{
Encaps curr = _encapsCache;
if(curr != null)
{
curr.reset();
_encapsCache = _encapsCache.next;
}
else
{
curr = new Encaps();
}
curr.next = _encapsStack;
_encapsStack = curr;
_encapsStack.start = _buf.b.position();
//
// I don't use readSize() 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(), it could be 1 or 5 bytes.
//
int sz = readInt();
if(sz < 6)
{
throw new UnmarshalOutOfBoundsException();
}
if(sz - 4 > _buf.b.remaining())
{
throw new UnmarshalOutOfBoundsException();
}
_encapsStack.sz = sz;
EncodingVersion encoding = new EncodingVersion();
encoding.read__(this);
Protocol.checkSupportedEncoding(encoding); // Make sure the encoding is supported.
_encapsStack.setEncoding(encoding);
return encoding;
}
