/// <summary>
        /// Reads the portable object.
        /// </summary>
        private T ReadPortableObject <T>(bool doDetach)
        {
            var len = Stream.ReadInt();

            var portablePos = Stream.Position;

            if (_mode != PortableMode.Deserialize)
            {
                return(TypeCaster <T> .Cast(ReadAsPortable(portablePos, len, doDetach)));
            }

            Stream.Seek(len, SeekOrigin.Current);

            var offset = Stream.ReadInt();

            var retPos = Stream.Position;

            Stream.Seek(portablePos + offset, SeekOrigin.Begin);

            _mode = PortableMode.KeepPortable;

            try
            {
                return(Deserialize <T>());
            }
            finally
            {
                _mode = PortableMode.Deserialize;

                Stream.Seek(retPos, SeekOrigin.Begin);
            }
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="marsh">Marshaller.</param>
        /// <param name="descs">Descriptors.</param>
        /// <param name="stream">Input stream.</param>
        /// <param name="mode">The mode.</param>
        /// <param name="builder">Builder.</param>
        public PortableReaderImpl
            (PortableMarshaller marsh,
            IDictionary <long, IPortableTypeDescriptor> descs,
            IPortableStream stream,
            PortableMode mode,
            PortableBuilderImpl builder)
        {
            _marsh   = marsh;
            _descs   = descs;
            _mode    = mode;
            _builder = builder;

            Stream = stream;
        }
Exemple #3
0
        /// <summary>
        /// Internal deserialization routine.
        /// </summary>
        /// <param name="mode">The mode.</param>
        /// <returns>
        /// Deserialized object.
        /// </returns>
        private T Deserialize <T>(PortableMode mode)
        {
            if (_deserialized == null)
            {
                IPortableStream stream = new PortableHeapStream(_data);

                stream.Seek(_offset, SeekOrigin.Begin);

                T res = _marsh.Unmarshal <T>(stream, mode);

                IPortableTypeDescriptor desc = _marsh.Descriptor(true, _typeId);

                if (!desc.KeepDeserialized)
                {
                    return(res);
                }

                _deserialized = res;
            }

            return((T)_deserialized);
        }
Exemple #4
0
 /// <summary>
 /// Start unmarshal session.
 /// </summary>
 /// <param name="stream">Stream.</param>
 /// <param name="mode">The mode.</param>
 /// <returns>Reader.</returns>
 public PortableReaderImpl StartUnmarshal(IPortableStream stream, PortableMode mode = PortableMode.Deserialize)
 {
     return(new PortableReaderImpl(this, _idToDesc, stream, mode, null));
 }
Exemple #5
0
 /// <summary>
 /// Unmarshal object.
 /// </summary>
 /// <param name="stream">Stream over underlying byte array with correct position.</param>
 /// <param name="mode">The mode.</param>
 /// <param name="builder">Builder.</param>
 /// <returns>
 /// Object.
 /// </returns>
 public T Unmarshal <T>(IPortableStream stream, PortableMode mode, PortableBuilderImpl builder)
 {
     return(new PortableReaderImpl(this, _idToDesc, stream, mode, builder).Deserialize <T>());
 }
Exemple #6
0
 /// <summary>
 /// Unmarshal object.
 /// </summary>
 /// <param name="stream">Stream over underlying byte array with correct position.</param>
 /// <param name="mode">The mode.</param>
 /// <returns>
 /// Object.
 /// </returns>
 public T Unmarshal <T>(IPortableStream stream, PortableMode mode = PortableMode.Deserialize)
 {
     return(Unmarshal <T>(stream, mode, null));
 }
Exemple #7
0
 /// <summary>
 /// Unmarshal object.
 /// </summary>
 /// <param name="data">Data array.</param>
 /// <param name="mode">The mode.</param>
 /// <returns>
 /// Object.
 /// </returns>
 public T Unmarshal <T>(byte[] data, PortableMode mode = PortableMode.Deserialize)
 {
     return(Unmarshal <T>(new PortableHeapStream(data), mode));
 }