VersionedStream.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Base / MS / Internal / IO / Packaging / CompoundFile / VersionedStream.cs / 1305600 / VersionedStream.cs

                            //------------------------------------------------------------------------------ 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: 
//   This class provides file versioning support for streams provided by 
//   IDataTransform implementations.
// 
// History:
//  02/21/2006: BruceMac: Initial implementation.
//
//----------------------------------------------------------------------------- 

using System; 
using System.IO;                                // for Stream 
using System.Windows;                           // ExceptionStringTable
using System.Globalization;                     // for CultureInfo 
using MS.Internal.WindowsBase;

namespace MS.Internal.IO.Packaging.CompoundFile
{ 
    /// 
    /// Maintains a FormatVersion for this stream and any number of sibling streams that semantically 
    /// share the same version information (which is only persisted in one of the streams). 
    /// 
    internal class VersionedStream : Stream 
    {
        //-----------------------------------------------------
        //
        //  Public Methods 
        //
        //----------------------------------------------------- 
        #region Stream Methods 
        /// 
        /// Return the bytes requested from the container 
        /// 
        public override int Read(byte[] buffer, int offset, int count)
        {
            CheckDisposed(); 

            // ReadAttempt accepts an optional boolean.  If this is true, that means 
            // we are expecting a legal FormatVersion to exist and that it is readable by our 
            // code version.  We do not want to force this check if we are empty.
            _versionOwner.ReadAttempt(_stream.Length > 0); 
            return _stream.Read(buffer, offset, count);
        }

        ///  
        /// Write
        ///  
        public override void Write(byte[] buffer, int offset, int count) 
        {
            CheckDisposed(); 
            _versionOwner.WriteAttempt();
            _stream.Write(buffer, offset, count);
        }
 
        /// 
        /// ReadByte 
        ///  
        public override int ReadByte()
        { 
            CheckDisposed();

            // ReadAttempt accepts an optional boolean.  If this is true, that means
            // we are expecting a legal FormatVersion to exist and that it is readable by our 
            // code version.  We do not want to force this check if we are empty.
            _versionOwner.ReadAttempt(_stream.Length > 0); 
            return _stream.ReadByte(); 
        }
 
        /// 
        /// WriteByte
        /// 
        public override void WriteByte(byte b) 
        {
            CheckDisposed(); 
            _versionOwner.WriteAttempt(); 
            _stream.WriteByte(b);
        } 

        /// 
        /// Seek
        ///  
        /// offset
        /// origin 
        /// zero 
        public override long Seek(long offset, SeekOrigin origin)
        { 
            CheckDisposed();
            return _stream.Seek(offset, origin);
        }
 
        /// 
        /// SetLength 
        ///  
        public override void SetLength(long newLength)
        { 
            CheckDisposed();

            if (newLength < 0)
                throw new ArgumentOutOfRangeException("newLength"); 

            _versionOwner.WriteAttempt(); 
            _stream.SetLength(newLength); 
        }
 
        /// 
        /// Flush
        /// 
        public override void Flush() 
        {
            CheckDisposed(); 
            _stream.Flush(); 
        }
        #endregion Stream Methods 

        //------------------------------------------------------
        //
        //  Public Properties 
        //
        //----------------------------------------------------- 
        #region Stream Properties 
        /// 
        /// Current logical position within the stream 
        /// 
        public override long Position
        {
            get 
            {
                CheckDisposed(); 
                return _stream.Position; 
            }
            set 
            {
                Seek(value, SeekOrigin.Begin);
            }
        } 

        ///  
        /// Length 
        /// 
        public override long Length 
        {
            get
            {
                CheckDisposed(); 
                return _stream.Length;
            } 
        } 

        ///  
        /// Is stream readable?
        /// 
        /// returns false when called on disposed stream
        public override bool CanRead 
        {
            get 
            { 
                return (_stream != null) && _stream.CanRead && _versionOwner.IsReadable;
            } 
        }

        /// 
        /// Is stream seekable - should be handled by our owner 
        /// 
        /// returns false when called on disposed stream 
        public override bool CanSeek 
        {
            get 
            {
                return (_stream != null) && _stream.CanSeek && _versionOwner.IsReadable;
            }
        } 

        ///  
        /// Is stream writeable? 
        /// 
        /// returns false when called on disposed stream 
        public override bool CanWrite
        {
            get
            { 
                return (_stream != null) && _stream.CanWrite && _versionOwner.IsUpdatable;
            } 
        } 
        #endregion
 
        //------------------------------------------------------
        //
        //  Internal Methods
        // 
        //------------------------------------------------------
        ///  
        /// Constructor to use for any stream that shares versioning information with another stream 
        /// but is not the one that houses the FormatVersion data itself.
        ///  
        /// 
        /// 
        internal VersionedStream(Stream baseStream, VersionedStreamOwner versionOwner)
        { 
            if (baseStream == null)
                throw new ArgumentNullException("baseStream"); 
 
            if (versionOwner == null)
                throw new ArgumentNullException("versionOwner"); 

            _stream = baseStream;
            _versionOwner = versionOwner;
        } 

        //----------------------------------------------------- 
        // 
        //  Protected Methods
        // 
        //------------------------------------------------------
        /// 
        /// Constructor for use by our subclass VersionedStreamOwner.
        ///  
        /// 
        protected VersionedStream(Stream baseStream) 
        { 
            if (baseStream == null)
                throw new ArgumentNullException("baseStream"); 

            _stream = baseStream;

            // we are actually a VersionedStreamOwner 
            _versionOwner = (VersionedStreamOwner)this;
        } 
 
        /// 
        /// Sometimes our subclass needs to read/write directly to the stream 
        /// 
        /// Don't use CheckDisposed() here as we need to return null if we are disposed
        protected Stream BaseStream
        { 
            get
            { 
                return _stream; 
            }
        } 

        /// 
        /// Dispose(bool)
        ///  
        /// 
        protected override void Dispose(bool disposing) 
        { 
            try
            { 
                if (disposing && (_stream != null))
                {
                    _stream.Close();
                } 
            }
            finally 
            { 
                _stream = null;
                base.Dispose(disposing); 
            }
        }

        ///  
        /// Call this before accepting any public API call (except some Stream calls that
        /// are allowed to respond even when Closed 
        ///  
        protected void CheckDisposed()
        { 
            if (_stream == null)
                throw new ObjectDisposedException(null, SR.Get(SRID.StreamObjectDisposed));
        }
 
        //-----------------------------------------------------
        // 
        //  Private Fields 
        //
        //----------------------------------------------------- 
        private VersionedStreamOwner    _versionOwner;
        private Stream                  _stream;            // null indicates Disposed state
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK