mcs/class/System.IO.Compression/SharpCompress/IO/RewindableStream.cs

   1 using System.IO;
   2
   3 namespace SharpCompress.IO
   4 {
   5     internal class RewindableStream : Stream
   6     {
   7         private readonly Stream stream;
   8         private MemoryStream bufferStream = new MemoryStream();
   9         private bool isRewound;
  10         private bool isDisposed;
  11
  12         public RewindableStream(Stream stream)
  13         {
  14             this.stream = stream;
  15         }
  16
  17         internal bool IsRecording { get; private set; }
  18
  19         protected override void Dispose(bool disposing)
  20         {
  21             if (isDisposed)
  22             {
  23                 return;
  24             }
  25             isDisposed = true;
  26             base.Dispose(disposing);
  27             if (disposing)
  28             {
  29                 stream.Dispose();
  30             }
  31         }
  32
  33         public void Rewind(bool stopRecording)
  34         {
  35             isRewound = true;
  36             IsRecording = !stopRecording;
  37             bufferStream.Position = 0;
  38         }
  39
  40         public void Rewind(MemoryStream buffer)
  41         {
  42             if (bufferStream.Position >= buffer.Length)
  43             {
  44                 bufferStream.Position -= buffer.Length;
  45             }
  46             else
  47             {
  48                 bufferStream.TransferTo(buffer);
  49                 bufferStream = buffer;
  50                 bufferStream.Position = 0;
  51             }
  52             isRewound = true;
  53         }
  54
  55         public void StartRecording()
  56         {
  57             //if (isRewound && bufferStream.Position != 0)
  58             //   throw new System.NotImplementedException();
  59             if (bufferStream.Position != 0)
  60             {
  61                 byte[] data = bufferStream.ToArray();
  62                 long position = bufferStream.Position;
  63                 bufferStream.SetLength(0);
  64                 bufferStream.Write(data, (int)position, data.Length - (int)position);
  65                 bufferStream.Position = 0;
  66             }
  67             IsRecording = true;
  68         }
  69
  70         public override bool CanRead
  71         {
  72             get { return true; }
  73         }
  74
  75         public override bool CanSeek
  76         {
  77             get { return false; }
  78         }
  79
  80         public override bool CanWrite
  81         {
  82             get { return false; }
  83         }
  84
  85         public override void Flush()
  86         {
  87             throw new System.NotImplementedException();
  88         }
  89
  90         public override long Length
  91         {
  92             get { throw new System.NotImplementedException(); }
  93         }
  94
  95         public override long Position
  96         {
  97             get { return stream.Position + bufferStream.Position - bufferStream.Length; }
  98             set
  99             {
 100                 if (!isRewound)
 101                 {
 102                     stream.Position = value;
 103                 }
 104                 else if (value < stream.Position - bufferStream.Length || value >= stream.Position)
 105                 {
 106                     stream.Position = value;
 107                     isRewound = false;
 108                     bufferStream.SetLength(0);
 109                 }
 110                 else
 111                 {
 112                     bufferStream.Position = value - stream.Position + bufferStream.Length;
 113                 }
 114             }
 115         }
 116
 117         public override int Read(byte[] buffer, int offset, int count)
 118         {
 119             int read;
 120             if (isRewound && bufferStream.Position != bufferStream.Length)
 121             {
 122                 read = bufferStream.Read(buffer, offset, count);
 123                 if (read < count)
 124                 {
 125                     int tempRead = stream.Read(buffer, offset + read, count - read);
 126                     if (IsRecording)
 127                     {
 128                         bufferStream.Write(buffer, offset + read, tempRead);
 129                     }
 130                     read += tempRead;
 131                 }
 132                 if (bufferStream.Position == bufferStream.Length && !IsRecording)
 133                 {
 134                     isRewound = false;
 135                     bufferStream.SetLength(0);
 136                 }
 137                 return read;
 138             }
 139
 140             read = stream.Read(buffer, offset, count);
 141             if (IsRecording)
 142             {
 143                 bufferStream.Write(buffer, offset, read);
 144             }
 145             return read;
 146         }
 147
 148         public override long Seek(long offset, SeekOrigin origin)
 149         {
 150             throw new System.NotImplementedException();
 151         }
 152
 153         public override void SetLength(long value)
 154         {
 155             throw new System.NotImplementedException();
 156         }
 157
 158         public override void Write(byte[] buffer, int offset, int count)
 159         {
 160             throw new System.NotImplementedException();
 161         }
 162     }
 163 }