2 // System.IO.MemoryStream
4 // Authors: Marcin Szczepanski (marcins@zipworld.com.au)
6 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
8 // (c) 2001,2002 Marcin Szczepanski, Patrik Torstensson
9 // (c) 2003 Ximian, Inc. (http://www.ximian.com)
10 // Copyright (C) 2004 Novell (http://www.novell.com)
14 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
16 // Permission is hereby granted, free of charge, to any person obtaining
17 // a copy of this software and associated documentation files (the
18 // "Software"), to deal in the Software without restriction, including
19 // without limitation the rights to use, copy, modify, merge, publish,
20 // distribute, sublicense, and/or sell copies of the Software, and to
21 // permit persons to whom the Software is furnished to do so, subject to
22 // the following conditions:
24 // The above copyright notice and this permission notice shall be
25 // included in all copies or substantial portions of the Software.
27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
36 using System
.Globalization
;
37 using System
.Runtime
.InteropServices
;
42 [MonoTODO ("Fix serialization compatibility with MS.NET")]
43 public class MemoryStream
: Stream
49 byte [] internalBuffer
;
55 public MemoryStream () : this (0)
59 public MemoryStream (int capacity
)
62 throw new ArgumentOutOfRangeException ("capacity");
66 this.capacity
= capacity
;
67 internalBuffer
= new byte [capacity
];
70 allowGetBuffer
= true;
73 public MemoryStream (byte [] buffer
)
76 throw new ArgumentNullException ("buffer");
78 InternalConstructor (buffer
, 0, buffer
.Length
, true, false);
81 public MemoryStream (byte [] buffer
, bool writeable
)
84 throw new ArgumentNullException ("buffer");
86 InternalConstructor (buffer
, 0, buffer
.Length
, writeable
, false);
89 public MemoryStream (byte [] buffer
, int index
, int count
)
91 InternalConstructor (buffer
, index
, count
, true, false);
94 public MemoryStream (byte [] buffer
, int index
, int count
, bool writeable
)
96 InternalConstructor (buffer
, index
, count
, writeable
, false);
99 public MemoryStream (byte [] buffer
, int index
, int count
, bool writeable
, bool publicallyVisible
)
101 InternalConstructor (buffer
, index
, count
, writeable
, publicallyVisible
);
104 void InternalConstructor (byte [] buffer
, int index
, int count
, bool writeable
, bool publicallyVisible
)
107 throw new ArgumentNullException ("buffer");
109 if (index
< 0 || count
< 0)
110 throw new ArgumentOutOfRangeException ("index or count is less than 0.");
112 if (buffer
.Length
- index
< count
)
113 throw new ArgumentException ("index+count",
114 "The size of the buffer is less than index + count.");
116 canWrite
= writeable
;
118 internalBuffer
= buffer
;
119 capacity
= count
+ index
;
122 initialIndex
= index
;
124 allowGetBuffer
= publicallyVisible
;
128 void CheckIfClosedThrowDisposed ()
131 throw new ObjectDisposedException ("MemoryStream");
134 void CheckIfClosedThrowIO ()
137 throw new IOException ("MemoryStream is closed");
140 public override bool CanRead
{
141 get { return !streamClosed; }
144 public override bool CanSeek
{
145 get { return !streamClosed; }
148 public override bool CanWrite
{
149 get { return (!streamClosed && canWrite); }
152 public virtual int Capacity
{
154 CheckIfClosedThrowDisposed ();
155 return capacity
- initialIndex
;
159 CheckIfClosedThrowDisposed ();
160 if (value == capacity
)
161 return; // LAMENESS: see MemoryStreamTest.ConstructorFive
164 throw new NotSupportedException ("Cannot expand this MemoryStream");
166 if (value < 0 || value < length
)
167 throw new ArgumentOutOfRangeException ("value",
168 "New capacity cannot be negative or less than the current capacity " + value + " " + capacity
);
170 byte [] newBuffer
= null;
172 newBuffer
= new byte [value];
173 Buffer
.BlockCopyInternal (internalBuffer
, 0, newBuffer
, 0, length
);
176 internalBuffer
= newBuffer
; // It's null when capacity is set to 0
181 public override long Length
{
183 // LAMESPEC: The spec says to throw an IOException if the
184 // stream is closed and an ObjectDisposedException if
185 // "methods were called after the stream was closed". What
186 // is the difference?
188 CheckIfClosedThrowDisposed ();
190 // This is ok for MemoryStreamTest.ConstructorFive
191 return length
- initialIndex
;
195 public override long Position
{
197 CheckIfClosedThrowDisposed ();
198 return position
- initialIndex
;
202 CheckIfClosedThrowDisposed ();
204 throw new ArgumentOutOfRangeException ("value",
205 "Position cannot be negative" );
207 if (value > Int32
.MaxValue
)
208 throw new ArgumentOutOfRangeException ("value",
209 "Position must be non-negative and less than 2^31 - 1 - origin");
211 position
= initialIndex
+ (int) value;
215 public override void Close ()
221 public override void Flush ()
226 public virtual byte [] GetBuffer ()
229 throw new UnauthorizedAccessException ();
231 return internalBuffer
;
234 public override int Read ([In
,Out
] byte [] buffer
, int offset
, int count
)
236 CheckIfClosedThrowDisposed ();
239 throw new ArgumentNullException ("buffer");
241 if (offset
< 0 || count
< 0)
242 throw new ArgumentOutOfRangeException ("offset or count less than zero.");
244 if (buffer
.Length
- offset
< count
)
245 throw new ArgumentException ("offset+count",
246 "The size of the buffer is less than offset + count.");
248 if (position
>= length
|| count
== 0)
251 if (position
> length
- count
)
252 count
= length
- position
;
254 Buffer
.BlockCopyInternal (internalBuffer
, position
, buffer
, offset
, count
);
259 public override int ReadByte ()
261 CheckIfClosedThrowDisposed ();
262 if (position
>= length
)
265 return internalBuffer
[position
++];
268 public override long Seek (long offset
, SeekOrigin loc
)
270 CheckIfClosedThrowDisposed ();
272 // It's funny that they don't throw this exception for < Int32.MinValue
273 if (offset
> (long) Int32
.MaxValue
)
274 throw new ArgumentOutOfRangeException ("Offset out of range. " + offset
);
278 case SeekOrigin
.Begin
:
280 throw new IOException ("Attempted to seek before start of MemoryStream.");
281 refPoint
= initialIndex
;
283 case SeekOrigin
.Current
:
290 throw new ArgumentException ("loc", "Invalid SeekOrigin");
293 // LAMESPEC: My goodness, how may LAMESPECs are there in this
294 // class! :) In the spec for the Position property it's stated
295 // "The position must not be more than one byte beyond the end of the stream."
296 // In the spec for seek it says "Seeking to any location beyond the length of the
297 // stream is supported." That's a contradiction i'd say.
298 // I guess seek can go anywhere but if you use position it may get moved back.
300 refPoint
+= (int) offset
;
301 if (refPoint
< initialIndex
)
302 throw new IOException ("Attempted to seek before start of MemoryStream.");
308 int CalculateNewCapacity (int minimum
)
311 minimum
= 256; // See GetBufferTwo test
313 if (minimum
< capacity
* 2)
314 minimum
= capacity
* 2;
319 public override void SetLength (long value)
321 if (!expandable
&& value > capacity
)
322 throw new NotSupportedException ("Expanding this MemoryStream is not supported");
324 CheckIfClosedThrowDisposed ();
327 throw new NotSupportedException (Locale
.GetText
328 ("Cannot write to this MemoryStream"));
331 // LAMESPEC: AGAIN! It says to throw this exception if value is
332 // greater than "the maximum length of the MemoryStream". I haven't
333 // seen anywhere mention what the maximum length of a MemoryStream is and
334 // since we're this far this memory stream is expandable.
335 if (value < 0 || (value + initialIndex
) > (long) Int32
.MaxValue
)
336 throw new ArgumentOutOfRangeException ();
338 int newSize
= (int) value + initialIndex
;
339 if (newSize
> capacity
)
340 Capacity
= CalculateNewCapacity (newSize
);
341 else if (newSize
< length
)
342 // zeroize present data (so we don't get it
343 // back if we expand the stream using Seek)
344 Array
.Clear (internalBuffer
, newSize
, length
- newSize
);
347 if (position
> length
)
351 public virtual byte [] ToArray ()
353 int l
= length
- initialIndex
;
354 byte[] outBuffer
= new byte [l
];
356 Buffer
.BlockCopyInternal (internalBuffer
, initialIndex
, outBuffer
, 0, l
);
360 public override void Write (byte [] buffer
, int offset
, int count
)
362 CheckIfClosedThrowDisposed ();
365 throw new NotSupportedException ("Cannot write to this stream.");
368 throw new ArgumentNullException ("buffer");
370 if (offset
< 0 || count
< 0)
371 throw new ArgumentOutOfRangeException ();
373 if (buffer
.Length
- offset
< count
)
374 throw new ArgumentException ("offset+count",
375 "The size of the buffer is less than offset + count.");
377 // reordered to avoid possible integer overflow
378 if (position
> capacity
- count
)
379 Capacity
= CalculateNewCapacity (position
+ count
);
381 Buffer
.BlockCopyInternal (buffer
, offset
, internalBuffer
, position
, count
);
383 if (position
>= length
)
387 public override void WriteByte (byte value)
389 CheckIfClosedThrowDisposed ();
391 throw new NotSupportedException ("Cannot write to this stream.");
393 if (position
>= capacity
)
394 Capacity
= CalculateNewCapacity (position
+ 1);
396 if (position
>= length
)
397 length
= position
+ 1;
399 internalBuffer
[position
++] = value;
402 public virtual void WriteTo (Stream stream
)
404 CheckIfClosedThrowDisposed ();
407 throw new ArgumentNullException ("stream");
409 stream
.Write (internalBuffer
, initialIndex
, length
- initialIndex
);