BGC.IO.SubStream Class Reference

Wraps a stream and grants access only to a subsection Modified from code found here: https://social.msdn.microsoft.com/Forums/vstudio/en-US/c409b63b-37df-40ca-9322-458ffe06ea48/how-to-access-part-of-a-filestream-or-memorystream?forum=netfxbcl More...

Inheritance diagram for BGC.IO.SubStream:

Collaboration diagram for BGC.IO.SubStream:

Public Member Functions
	SubStream (Stream baseStream, long startPosition, long length, bool ownsStream=false)
	SubStream (Stream baseStream, long length, bool ownsStream=false)
override int	ReadByte ()
override int	Read (byte[] buffer, int offset, int count)
override void	Flush ()
override long	Seek (long offset, SeekOrigin origin)
override void	SetLength (long value)
override void	Write (byte[] buffer, int offset, int count)

Protected Member Functions
override void	Dispose (bool disposing)

Properties
override long	Length [get]
override bool	CanRead [get]
override bool	CanWrite [get]
override bool	CanSeek [get]
override long	Position [get, set]

Private Member Functions
void	CheckDisposed ()

Private Attributes
readonly bool	ownsStream
readonly long	length
readonly long	startPosition
Stream	baseStream = null
long	position = 0
bool	_disposed = false

Detailed Description

Wraps a stream and grants access only to a subsection Modified from code found here: https://social.msdn.microsoft.com/Forums/vstudio/en-US/c409b63b-37df-40ca-9322-458ffe06ea48/how-to-access-part-of-a-filestream-or-memorystream?forum=netfxbcl

Definition at line 13 of file SubStream.cs.

Constructor & Destructor Documentation

SubStream() [1/2]

BGC.IO.SubStream.SubStream ( Stream  baseStream, long  startPosition, long  length, bool  ownsStream = false  )

inline

Definition at line 68 of file SubStream.cs.

        {
            if (baseStream == null)
            {
                throw new ArgumentNullException(nameof(baseStream));
            }

            if (!baseStream.CanRead)
            {
                throw new ArgumentException("Can't read BaseStream");
            }

            if (startPosition < 0 || startPosition + length > baseStream.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(startPosition));
            }

            this.baseStream = baseStream;
            this.length = length;
            this.ownsStream = ownsStream;
            this.startPosition = startPosition;
            position = 0;

            if (baseStream.Position != startPosition)
            {
                if (baseStream.CanSeek)
                {
                    baseStream.Seek(startPosition, SeekOrigin.Begin);
                }
                else if (baseStream.Position > startPosition)
                {
                    //Can't seek and we're past the start position
                    throw new NotSupportedException("BaseStream can't seek backwards to StartPosition");
                }
                else
                {
                    // fast forward manually...
                    const int BUFFER_SIZE = 512;
                    byte[] buffer = new byte[BUFFER_SIZE];
                    long deltaPosition = startPosition - baseStream.Position;
                    while (deltaPosition > 0)
                    {
                        int read = baseStream.Read(
                            buffer: buffer,
                            offset: 0,
                            count: deltaPosition < BUFFER_SIZE ? (int)deltaPosition : BUFFER_SIZE);

                        deltaPosition -= read;

                        if (read == 0)
                        {
                            throw new Exception("Failed to read past required samples");
                        }
                    }
                }
            }
        }

SubStream() [2/2]

BGC.IO.SubStream.SubStream ( Stream  baseStream, long  length, bool  ownsStream = false  )

inline

Definition at line 130 of file SubStream.cs.

        {
            if (baseStream == null)
            {
                throw new ArgumentNullException("baseStream");
            }

            if (!baseStream.CanRead)
            {
                throw new ArgumentException("Can't read base stream");
            }

            this.baseStream = baseStream;
            this.length = length;
            this.ownsStream = ownsStream;
            startPosition = baseStream.Position;
            position = 0;
        }

Member Function Documentation

CheckDisposed()

void BGC.IO.SubStream.CheckDisposed ( )

inlineprivate

Definition at line 225 of file SubStream.cs.

        {
            if (_disposed || baseStream == null)
            {
                throw new ObjectDisposedException(GetType().Name);
            }
        }

Dispose()

override void BGC.IO.SubStream.Dispose ( bool  disposing )

inlineprotected

Definition at line 236 of file SubStream.cs.

        {
            base.Dispose(disposing);

            if (_disposed)
            {
                return;
            }

            if (disposing)
            {
                if (baseStream != null)
                {
                    if (ownsStream)
                    {
                        try
                        {
                            baseStream.Dispose();
                        }
                        catch
                        {
                            //Dodge dispose exceptions
                        }
                    }
                    else
                    {
                        //Try advancing stream to end
                        if (baseStream.CanSeek)
                        {
                            baseStream.Seek(startPosition + length, SeekOrigin.Begin);
                        }
                    }

                    baseStream = null;
                }
            }

            _disposed = true;
        }

Flush()

override void BGC.IO.SubStream.Flush ( )

inline

Definition at line 180 of file SubStream.cs.

        {
            CheckDisposed();
            baseStream.Flush();
        }

Read()

override int BGC.IO.SubStream.Read ( byte []  buffer, int  offset, int  count  )

inline

Definition at line 164 of file SubStream.cs.

        {
            CheckDisposed();

            count = (int)Math.Min(count, length - position);
            if (count <= 0)
            {
                return 0;
            }

            int read = baseStream.Read(buffer, offset, count);
            position += read;

            return read;
        }

ReadByte()

override int BGC.IO.SubStream.ReadByte ( )

inline

Definition at line 152 of file SubStream.cs.

        {
            if (length - position <= 0)
            {
                return -1;
            }

            position++;

            return baseStream.ReadByte();
        }

Seek()

override long BGC.IO.SubStream.Seek ( long  offset, SeekOrigin  origin  )

inline

Definition at line 186 of file SubStream.cs.

References BGC.Mathematics.GeneralMath.Clamp().

        {
            if (!CanSeek)
            {
                throw new NotSupportedException("BaseStream does not support seeking");
            }

            switch (origin)
            {
                case SeekOrigin.Begin:
                    offset = GeneralMath.Clamp(offset, 0, length);
                    position = offset;
                    offset += startPosition;
                    break;

                case SeekOrigin.Current:
                    offset = GeneralMath.Clamp(offset, -position, length - position);
                    position += offset;
                    break;

                case SeekOrigin.End:
                    offset = GeneralMath.Clamp(offset, -length, 0);
                    position = length + offset;
                    offset -= baseStream.Length - (startPosition + Length);
                    break;

                default:
                    throw new NotSupportedException($"SeekOrigin not implemented: {origin}");
            }

            baseStream.Seek(offset, origin);

            return position;
        }

Here is the call graph for this function:

SetLength()

override void BGC.IO.SubStream.SetLength

(

long

value

)

Write()

override void BGC.IO.SubStream.Write	(	byte []	buffer,
		int	offset,
		int	count
	)

Field Documentation

_disposed

bool BGC.IO.SubStream._disposed = false

private

Definition at line 235 of file SubStream.cs.

baseStream

Stream BGC.IO.SubStream.baseStream = null

private

Definition at line 19 of file SubStream.cs.

length

readonly long BGC.IO.SubStream.length

private

Definition at line 16 of file SubStream.cs.

ownsStream

readonly bool BGC.IO.SubStream.ownsStream

private

Definition at line 15 of file SubStream.cs.

position

long BGC.IO.SubStream.position = 0

private

Definition at line 20 of file SubStream.cs.

startPosition

readonly long BGC.IO.SubStream.startPosition

private

Definition at line 17 of file SubStream.cs.

Property Documentation

CanRead

override bool BGC.IO.SubStream.CanRead

get

Definition at line 32 of file SubStream.cs.

CanSeek

override bool BGC.IO.SubStream.CanSeek

get

Definition at line 50 of file SubStream.cs.

CanWrite

override bool BGC.IO.SubStream.CanWrite

get

Definition at line 41 of file SubStream.cs.

Length

override long BGC.IO.SubStream.Length

get

Definition at line 23 of file SubStream.cs.

Position

override long BGC.IO.SubStream.Position

getset

Definition at line 59 of file SubStream.cs.

---

The documentation for this class was generated from the following file:

• IO/SubStream.cs