jellyfin/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/InputStream.cs

using System;
using System.IO;

namespace SharpCifs.Util.Sharpen
{
    public class InputStream : IDisposable
	{
		private long _mark;
		protected Stream Wrapped;
		protected Stream BaseStream;

		public static implicit operator InputStream (Stream s)
		{
			return Wrap (s);
		}

		public static implicit operator Stream (InputStream s)
		{
			return s.GetWrappedStream ();
		}

		public virtual int Available ()
		{
		    if (Wrapped is WrappedSystemStream)
				return ((WrappedSystemStream)Wrapped).InputStream.Available ();
		    return 0;
		}

	    public virtual void Close ()
		{
			if (Wrapped != null) {
                //Stream.`Close` method deleted
				//Wrapped.Close ();
                Wrapped.Dispose();
            }
		}

		public void Dispose ()
		{
			Close ();
		}

        internal Stream GetWrappedStream ()
        {
			// Always create a wrapper stream (not directly Wrapped) since the subclass
			// may be overriding methods that need to be called when used through the Stream class
			return new WrappedSystemStream (this);
		}

		public virtual void Mark (int readlimit)
		{
			if (Wrapped is WrappedSystemStream)
				((WrappedSystemStream)Wrapped).InputStream.Mark (readlimit);
			else {
				if (BaseStream is WrappedSystemStream)
					((WrappedSystemStream)BaseStream).OnMark (readlimit);
				if (Wrapped != null)
					_mark = Wrapped.Position;
			}
		}
		
		public virtual bool MarkSupported ()
		{
		    if (Wrapped is WrappedSystemStream)
				return ((WrappedSystemStream)Wrapped).InputStream.MarkSupported ();
		    return ((Wrapped != null) && Wrapped.CanSeek);
		}

	    public virtual int Read ()
		{
			if (Wrapped == null) {
				throw new NotImplementedException ();
			}
			return Wrapped.ReadByte ();
		}

		public virtual int Read (byte[] buf)
		{
			return Read (buf, 0, buf.Length);
		}

		public virtual int Read (byte[] b, int off, int len)
		{
			if (Wrapped is WrappedSystemStream)
				return ((WrappedSystemStream)Wrapped).InputStream.Read (b, off, len);
			
			if (Wrapped != null) {
				int num = Wrapped.Read (b, off, len);
				return ((num <= 0) ? -1 : num);
			}
			int totalRead = 0;
			while (totalRead < len) {
				int nr = Read ();
				if (nr == -1)
					return -1;
				b[off + totalRead] = (byte)nr;
				totalRead++;
			}
			return totalRead;
		}

		public virtual void Reset ()
		{
			if (Wrapped is WrappedSystemStream)
				((WrappedSystemStream)Wrapped).InputStream.Reset ();
			else {
				if (Wrapped == null)
					throw new IOException ();
				Wrapped.Position = _mark;
			}
		}

		public virtual long Skip (long cnt)
		{
			if (Wrapped is WrappedSystemStream)
				return ((WrappedSystemStream)Wrapped).InputStream.Skip (cnt);
			
			long n = cnt;
			while (n > 0) {
				if (Read () == -1)
					return cnt - n;
				n--;
			}
			return cnt - n;
		}
		
		internal virtual bool CanSeek ()
		{
		    if (Wrapped != null)
				return Wrapped.CanSeek;
		    return false;
		}

	    internal virtual long Position {
			get
			{
			    if (Wrapped != null)
					return Wrapped.Position;
			    throw new NotSupportedException ();
			}
	        set {
				if (Wrapped != null)
					Wrapped.Position = value;
				else
					throw new NotSupportedException ();
			}
		}

        public virtual long Length
        {
            get
            {
                if (Wrapped != null)
                {
                    return Wrapped.Length;    
                }

                throw new NotSupportedException();
            }
        }

		static internal InputStream Wrap (Stream s)
		{
			InputStream stream = new InputStream ();
			stream.Wrapped = s;
			return stream;
		}
	}
}