public long Seek(long offset, SeekOrigin origin)
{
// no such thing as abstract in c...
// we need a vTable?
return __Stream_Seek(this, offset, origin);
}
public override long Seek(long offset, SeekOrigin origin)
{
int num = this._pos;
int num2 = (int) offset;
switch (origin)
{
case SeekOrigin.Begin:
num = num2;
break;
case SeekOrigin.Current:
num = this._pos + num2;
break;
case SeekOrigin.End:
num = this._length + num2;
break;
default:
throw new ArgumentOutOfRangeException("origin");
}
if ((num < 0) || (num > this._length))
{
throw new ArgumentOutOfRangeException("offset");
}
this._pos = num;
return (long) this._pos;
}
public IconImage(Stream imageStream, int offset, SeekOrigin origin, int size)
{
if (imageStream == null)
throw new ArgumentNullException("imageStream");
if (!(imageStream.CanRead && imageStream.CanSeek))
throw new ArgumentException("Can't read or seek stream", "imageStream");
if (size < 0)
throw new ArgumentOutOfRangeException("size");
if (origin != SeekOrigin.Current && offset < 0)
throw new ArgumentOutOfRangeException("offset");
if (((origin == SeekOrigin.Begin || origin == SeekOrigin.End) && offset > imageStream.Length) ||
(origin == SeekOrigin.Current && (imageStream.Position + offset < 0 || imageStream.Position + offset > imageStream.Length)))
throw new ArgumentOutOfRangeException("offset");
if ((origin == SeekOrigin.Begin && offset + size > imageStream.Length) ||
(origin == SeekOrigin.End && size > offset) ||
(origin == SeekOrigin.Current && (offset + size < 0 || offset + size > imageStream.Length)))
throw new ArgumentOutOfRangeException("size");
Parse(imageStream, offset, origin, size);
}
public override long Seek(long offset, SeekOrigin origin)
{
var len = Length;
switch (origin)
{
case SeekOrigin.Begin:
_position = offset;
break;
case SeekOrigin.Current:
_position += offset;
break;
case SeekOrigin.End:
_position = len - offset;
break;
}
if (_position > len)
{
_position = len;
}
else if (_position < 0)
{
_position = 0;
}
return _position;
}
private void AssertSeek(int offset, int length, int seekOffset, SeekOrigin seekOrigin)
{
var source = new MemoryStream(SourceData);
var streamlet = new Streamlet(source, offset, length);
streamlet.Seek(seekOffset, seekOrigin);
long sourcePosition;
long position;
switch (seekOrigin)
{
case SeekOrigin.Begin:
case SeekOrigin.Current:
sourcePosition = offset + seekOffset;
position = seekOffset;
break;
case SeekOrigin.End:
sourcePosition = offset + length - seekOffset;
position = length - seekOffset;
break;
default:
throw new NotSupportedException();
}
Assert.AreEqual(sourcePosition, source.Position);
Assert.AreEqual(position, streamlet.Position);
}
public void Seek(long offset, SeekOrigin origin)
{
int totalCount;
if (this._typeIsDocument)
totalCount = this._db.Statistics.CountOfDocuments;
else
totalCount = this._db.Statistics.CountOfIndexes;
if (offset > totalCount)
{
throw new
ArgumentException(
"Offset cannot be greater than the number of " + (_typeIsDocument ? "documents" : "indexes")
);
}
if (origin == SeekOrigin.Begin)
{
// starting from Beginning with an index 0, the current offset
// has to be advanced to offset - 1
_currentOffset = _currentOffset - 1;
}
else if (origin == SeekOrigin.End)
{
// starting from the end which is numRows - 1, the current
// offset is so much less than numRows - 1
_currentOffset = totalCount - 1 - _currentOffset;
}
else
{
// calculate from the previous value of current offset
// advancing forward always
_currentOffset += Convert.ToInt32(offset);
}
}
/// <summary>
/// Sets the current position of this stream to the given value.
/// </summary>
/// <param name="offset">
/// The point relative to <paramref name="origin"/> from which to begin seeking.
/// </param>
/// <param name="origin">
/// Specifies the beginning, the end, or the current position as a reference point for origin, using a value of type <see cref="SeekOrigin"/>.
/// </param>
/// <returns>
/// The new position in the stream.
/// </returns>
public override long Seek(long offset, SeekOrigin origin)
{
switch (origin)
{
case SeekOrigin.Begin:
if (this._position != offset)
{
this._position = offset;
base.Seek(offset, origin);
}
break;
case SeekOrigin.Current:
if (this._position != this._position + offset)
{
this._position += offset;
base.Seek(offset, origin);
}
break;
default:
this._position = base.Seek(offset, origin);
break;
}
return this._position;
}
public override Int64 Seek(Int64 offset, SeekOrigin origin) {
Contract.Requires((int)origin >= 0);
Contract.Requires((int)origin <= 2);
Contract.EnsuresOnThrow<System.IO.IOException>(true, @"An I/O error occurred.");
return default(Int64);
}
public override long Seek(long offset, SeekOrigin origin)
{
long newPosition = Position;
switch (origin)
{
case SeekOrigin.Begin:
newPosition = offset;
break;
case SeekOrigin.Current:
newPosition += offset;
break;
case SeekOrigin.End:
newPosition = Length - offset;
break;
default:
throw new ArgumentOutOfRangeException(nameof(origin));
}
// Is it valid?
if (0 > newPosition || newPosition > Length)
throw new ArgumentOutOfRangeException("Out of bounds");
// Valid
Position = newPosition;
// Position disk stream
long diskOffset = Position - Position % _smallestChunkSize; // Align to a multiple of '_smallestChunkSize'
Debug.Assert(diskOffset % _smallestChunkSize == 0);
_diskStream.Seek(diskOffset, SeekOrigin.Begin);
return Position;
}
/// <summary>
/// Sets the position within the current stream.
/// </summary>
/// <param name="offset">A byte offset relative to the <paramref name="origin"/> parameter.</param>
/// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"/> indicating the reference point used to obtain the new position.</param>
/// <returns>The new position within the current stream.</returns>
public override long Seek(long offset, SeekOrigin origin)
{
if (origin == SeekOrigin.Begin)
offset += m_baseOffset;
return base.Seek(offset, origin) - m_baseOffset;
}
/// <summary>
/// Seek
/// </summary>
/// <param name="offset">offset</param>
/// <param name="origin">origin</param>
/// <returns>zero</returns>
public override long Seek(long offset, SeekOrigin origin)
{
CheckDisposed();
long temp = 0;
switch (origin)
{
case SeekOrigin.Begin:
{
temp = offset;
break;
}
case SeekOrigin.Current:
{
checked { temp = _tempStream.Position + offset; }
break;
}
case SeekOrigin.End:
{
checked { temp = _tempStream.Length + offset; }
break;
}
default:
{
throw new ArgumentOutOfRangeException("origin", SR.Get(SRID.SeekOriginInvalid));
}
}
if (temp < 0)
{
throw new ArgumentException(SR.Get(SRID.SeekNegative));
}
return _tempStream.Seek(offset, origin);
}
public override long Seek(long offset, SeekOrigin origin)
{
lock (underlyingStream)
{
return underlyingStream.Seek(offset, origin);
}
}
public override long Seek(long offset, SeekOrigin origin)
{
long pos = 0;
switch (origin)
{
case SeekOrigin.Begin:
pos = offset;
break;
case SeekOrigin.Current:
pos = this.Position + offset;
break;
case SeekOrigin.End:
pos = Length + offset;
break;
}
int idx = 0;
while (idx+1 < _streamsStartPos.Count)
{
if (_streamsStartPos[idx + 1] > pos)
{
break;
}
idx++;
}
_currentStreamIndex = idx;
_currentStream = _streams[_currentStreamIndex];
_currentStream.Seek(pos - _streamsStartPos[idx], SeekOrigin.Begin);
_postion = pos;
return _postion;
//throw new InvalidOperationException("Stream is not seekable.");
}
public override long Seek(
long offset,
SeekOrigin origin
)
{
return _baseStream.Seek(offset, origin);
}
/// <summary>
/// Extracts the contents of the given stream according to the parameters and assigns them as the response payload.
/// </summary>
/// <param name="stream">The stream from which the data is extracted.</param>
/// <param name="offset">The offset at which to begin extraction relative to the seek origin.</param>
/// <param name="length">The number of bytes to copy. Usage of a negative number means copying everything to the end of the stream.</param>
/// <param name="origin">The point from which seeking in the stream should take place.</param>
/// <returns>The response object.</returns>
public Response SetPayload(Stream stream, SeekOrigin origin, int offset = 0, int length = -1)
{
if (Disposed)
throw new ObjectDisposedException(this.GetType().FullName, "Cannot change a disposed response!");
if (stream == null)
throw new ArgumentNullException("bt", "Payload cannot be null!");
if (str != null)
try
{
str.Dispose();
}
catch { }
stream.Seek(offset, origin);
if (length < 0)
length = (int)(stream.Length - stream.Position);
var ba = new byte[length];
int read = 0;
while (read < length)
{
read += stream.Read(ba, read, length - read);
}
str = new MemoryStream(ba);
return this;
}
/// <summary>
/// Seek
/// </summary>
/// <param name="offset">offset</param>
/// <param name="origin">origin</param>
/// <returns>zero</returns>
public override long Seek(long offset, SeekOrigin origin)
{
ReadAttempt();
long temp = -1;
switch (origin)
{
// seek beyond the FormatVersion
case SeekOrigin.Begin:
temp = offset;
break;
case SeekOrigin.Current:
checked { temp = Position + offset; }
break;
case SeekOrigin.End:
checked { temp = Length + offset; }
break;
}
if (temp < 0)
throw new ArgumentException(SR.Get(SRID.SeekNegative));
checked { BaseStream.Position = temp + _dataOffset; }
return temp;
}
//zis can't seek. do dummy reads instead
public override long Seek(long offset, SeekOrigin origin)
{
//convert all seekorigin into a seekorigin.current
if(origin == SeekOrigin.Begin) {
origin = SeekOrigin.Current;
position = 0;
zis = zf.GetInputStream(ze);
} else if(origin == SeekOrigin.End) {
origin = SeekOrigin.Current;
offset = (long)length - offset;
if(offset > position)
offset = position - offset;
else {
position = 0;
zis = zf.GetInputStream(ze);
}
}
long todo = offset;
byte[] buf = new byte[4096];
while(todo > 0) {
int work = 4096;
if(todo < work) work = (int)todo;
int done = zis.Read(buf, 0, work);
if(done == 0) throw new Exception("Couldn't complete seek");
todo -= done;
}
position += offset;
return position;
}
/// <summary>
/// Move the cursor.
/// </summary>
/// <param name="origin">Which origin to use for calculating the new
/// cursor position.</param>
/// <param name="offsetFromOrigin">The offset to apply,
/// relative to the specified origin.</param>
/// <param name="offsetFromPreviousPosition">On success, receives the
/// resulting offset moved from the previous position.</param>
/// <returns>True on success; false if the movement could not be made.
/// </returns>
public bool MoveCursor(SeekOrigin origin, int offsetFromOrigin, out int offsetFromPreviousPosition)
{
int startingIndex;
switch (origin)
{
case SeekOrigin.Begin:
startingIndex = 0;
break;
case SeekOrigin.Current:
startingIndex = CursorIndex;
break;
case SeekOrigin.End:
startingIndex = _buffer.Length;
break;
default:
throw new ArgumentOutOfRangeException(nameof(origin));
}
var newIndex = startingIndex + offsetFromOrigin;
if ((newIndex < 0) || (newIndex > _buffer.Length))
{
offsetFromPreviousPosition = 0;
return false;
}
offsetFromPreviousPosition = newIndex - CursorIndex;
CursorIndex = newIndex;
return true;
}
public override long Seek(long offset, SeekOrigin origin)
{
this.ValidateSeekable();
long beginOffset = this.GetBeginOffset(offset, origin);
if ((beginOffset > this._stream.Position) &&
(beginOffset < this._stream.Position + this._alignmentOffset))
{
this._alignmentOffset = (int)(beginOffset - this._stream.Position);
}
else
{
if (this.Position <= this.Length)
{
this.WriteAlignmentBuffer();
}
long alignedOffset = this.GetAlignedValue(beginOffset);
this._stream.Seek(alignedOffset, SeekOrigin.Begin);
this._alignmentOffset = (int)(beginOffset - alignedOffset);
if (false == this.IsValueAligned(beginOffset))
{
this.ReadAlignmentBuffer();
this._stream.Seek(alignedOffset, SeekOrigin.Begin);
}
}
return beginOffset;
}
public override long Seek(long offset, SeekOrigin origin)
{
var position = Position;
switch (origin)
{
case SeekOrigin.Begin:
position = offset;
break;
case SeekOrigin.Current:
position += offset;
break;
case SeekOrigin.End:
position = Length;
position += offset;
break;
}
if (position >= Stream1.Length)
Position = Stream1.Length + Stream2.Seek(offset - Stream1.Length, SeekOrigin.Begin);
else
Position = Stream1.Seek(offset, SeekOrigin.Begin);
return position;
}
public void Seek(long offset, SeekOrigin origin)
{
if ((offset != 0) || (origin != SeekOrigin.End))
{
throw new NotImplementedException();
}
}
public TemporarySeek(Stream stream, long offset, SeekOrigin origin = SeekOrigin.Begin)
{
m_stream = stream;
m_restoredPosition = stream.Position;
stream.Seek(offset, origin);
}
private long _Seek(long offset, SeekOrigin origin)
{
long toPos = 0;
var length = _blockProvider.GetLength(_path);
if (origin == SeekOrigin.Begin)
{
toPos = offset;
}
else if (origin == SeekOrigin.Current)
{
toPos = _pos + offset;
}
else if (origin == SeekOrigin.End)
{
toPos = length + offset;
}
/*
if (toPos < 0 || toPos > length)
{
throw new IOException("Invalid file position");
}
*/
if (toPos < 0)
{
throw new IOException("Invalid file position");
}
_pos = toPos;
return _pos;
}
public override long Seek(long offset, SeekOrigin origin)
{
this.ValidateSeekable();
long beginOffset = this.GetBeginOffset(offset, origin);
if ((beginOffset < this._stream.Position) &&
(beginOffset >= this._stream.Position - this._alignmentLength))
{
this._alignmentOffset = (int)(beginOffset - this._stream.Position);
}
else if (beginOffset == this._stream.Position)
{
this._alignmentOffset = 0;
this._alignmentLength = 0;
}
else
{
long alignedOffset = this.GetAlignedValue(beginOffset);
if (this._stream.Position != alignedOffset)
{
this._stream.Seek(alignedOffset, SeekOrigin.Begin);
}
this._alignmentOffset = (int)(beginOffset - alignedOffset);
this._alignmentLength = 0;
}
return beginOffset;
}
public override long Seek(long offset, SeekOrigin origin)
{
switch (origin)
{
case SeekOrigin.Begin:
{
if (offset != Position)
return base.Seek(offset, origin);
}
break;
case SeekOrigin.Current:
{
if (offset != 0)
return base.Seek(offset, origin);
}
break;
case SeekOrigin.End:
{
if (offset != Length - Position)
return base.Seek(offset, origin);
}
break;
}
return Position;
}
public override long Seek(long offset, SeekOrigin origin)
{
if (offset != 0L)
{
if ((offset < 0L) || ((origin != SeekOrigin.Current) && (!this.CanSeekFromBeginning || (origin != SeekOrigin.Begin))))
{
throw new ArgumentException();
}
if (this.CheckWriteOrFinished())
{
return 0L;
}
this.CanSeekFromBeginning = false;
while (offset >= (this.size - this.offset))
{
offset -= this.size - this.offset;
this.WriteEvent.Reset();
this.ReadEvent.Set();
if (this.CheckWriteOrFinished())
{
return 0L;
}
}
this.offset += (int) offset;
}
return 0L;
}
public override long Seek (long offset, SeekOrigin origin)
{
if (origin == SeekOrigin.Begin)
return Position = offset;
else
throw new NotSupportedException ();
}
public override long Seek(long offset, SeekOrigin origin)
{
return inner.Seek(offset, origin);
}
public void Seek(int offset, SeekOrigin origin)
{
switch (origin)
{
case SeekOrigin.Begin:
while (offset < 0)
offset += this._stringLength;
while (offset > this._stringLength)
offset -= this._stringLength;
while (offset > this.ReadedBuffer.Length)
{
this.Read();
}
this._position = offset;
break;
case SeekOrigin.Current:
this.Seek(offset + this._position, SeekOrigin.Begin);
break;
case SeekOrigin.End:
this.Seek(-offset, SeekOrigin.Begin);
break;
}
}
public override long Seek(long offset, SeekOrigin origin)
{
int oldPosition = _Position;
switch (origin)
{
case SeekOrigin.Begin:
_Position = (int)offset;
break;
case SeekOrigin.Current:
_Position += (int)offset;
break;
case SeekOrigin.End:
_Position = _Length + (int)offset;
break;
}
if (_Position >= _Length)
{
_Position = oldPosition;
throw new IOException("");
}
return _Position;
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
/// <param name="origin"></param>
/// <returns></returns>
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotImplementedException();
}
/// <summary>
/// Seeks the stream.
/// </summary>
/// <param name="offset">The offset to seek to.</param>
/// <param name="origin">The origin of the seek operation.</param>
/// <returns>The new position in the stream.</returns>
public override long Seek(long offset, SeekOrigin origin)
{
return(this.innerStream.Seek(offset, origin));
}
/// <summary>
/// Set the streams position. This operation is not supported and will throw a NotSupportedException
/// </summary>
/// <param name="offset">The offset relative to the origin to seek to.</param>
/// <param name="origin">The <see cref="SeekOrigin"/> to start seeking from.</param>
/// <returns>The new position in the stream.</returns>
/// <exception cref="NotSupportedException">Any access</exception>
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException("TarInputStream Seek not supported");
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new InvalidOperationException();
}
public override long Seek(long offset, SeekOrigin origin)
{
return(responseStream.Seek(offset, origin));
}
public override long Seek(long offset, SeekOrigin origin) => source.Seek(offset, origin);
/// <summary> /// 定位文件系统流位置。 /// </summary> /// <param name="offset">要定位的文件系统流位置的偏移。</param> /// <param name="origin">要定位的文件系统流位置的方式。</param> protected internal abstract void Seek(long offset, SeekOrigin origin);
/// <summary>
/// Sets the position within the current stream.
/// </summary>
/// <remarks>
/// The <see cref="TnefReaderStream"/> does not support seeking.
/// </remarks>
/// <returns>The new position within the stream.</returns>
/// <param name="offset">The offset into the stream relative to the <paramref name="origin"/>.</param>
/// <param name="origin">The origin to seek from.</param>
/// <exception cref="System.NotSupportedException">
/// The stream does not support seeking.
/// </exception>
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException("The stream does not support seeking.");
}
public override long Seek(long offset, SeekOrigin origin) => - 1;
public override long Seek(long offset, SeekOrigin loc)
{
this.HasBeenSeeked = true;
return(base.Seek(offset, loc));
}
public void Seek(long offset, SeekOrigin origin)
{
}
public override long Seek(long offset, SeekOrigin origin)
{
return(_backingStream.Seek(offset, origin));
}
public override Int64 Seek(Int64 offset, SeekOrigin origin)
{
ThrowIfDisposed();
throw new NotSupportedException(SR.SeekingNotSupported);
}
public override long Seek(long offset, SeekOrigin origin) => BaseStream.Seek(offset, origin);
/// <summary>
/// set the position within the current stream
/// </summary>
/// <param name="offset">The offset relative to the <paramref name="origin"/> to seek to</param>
/// <param name="origin">The <see cref="SeekOrigin"/> to seek from.</param>
/// <returns>The new position in the stream.</returns>
public override long Seek(long offset, SeekOrigin origin)
{
return(outputStream.Seek(offset, origin));
}
public override long Seek(long offset, SeekOrigin origin)
{
return(_sink.Seek(offset, origin));
}
/// <summary>
/// Seek
/// </summary>
/// <param name="offset">offset</param>
/// <param name="origin">origin</param>
public override long Seek(long offset, SeekOrigin origin)
{
CheckDisposed();
return(_obfuscatedStream.Seek(offset, origin));
}
override public long Seek(long pos, SeekOrigin so)
{
throw new NotSupportedException("Tried to seek non-seekable " + this);
}
/// <summary>
/// Seeks within the stream.
/// </summary>
/// <param name="offset">Offset to seek to.</param>
/// <param name="origin">Origin of seek operation.</param>
public void Seek(int offset, SeekOrigin origin)
{
CheckDisposed();
BaseStream.Seek(offset, origin);
}
private long seekFile(long off, SeekOrigin whence)
{
return(m_stream.Seek(m_clientdata, off, whence));
}
/// <summary>
/// Sets the current position of this stream to the given value.
/// </summary>
/// <param name="offset">The point relative to origin from which to begin seeking.</param>
/// <param name="origin">Specifies the beginning, the end, or the current position as a reference point for origin, using a value of type SeekOrigin. </param>
/// <returns>The new position in the stream.</returns>
public long Seek(long offset, SeekOrigin origin)
{
return(FileStreamInstance.Seek(offset, origin));
}
public override long Seek(long offset, SeekOrigin origin)
{
// Not surprisingly SeekOrigin is the same as STREAM_SEEK
// (given the history of .NET and COM)
return(Stream.Seek(offset, (StreamSeek)origin));
}
public override long Seek(long offset, SeekOrigin origin)
{
return(stream_.Seek(offset, origin));
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException(SR.NotSupported_UnseekableStream);
}
public abstract virtual long Seek(long offset, SeekOrigin origin)
{
}
/// <inheritdoc/>
public override long Seek(long offset, SeekOrigin origin)
{
return(_wrappedStream.Seek(offset, origin));
}
public override long Seek(long lOffset, SeekOrigin soOrigin)
{
Debug.Assert(false);
throw new NotSupportedException();
}
public override long Seek(long offset, SeekOrigin origin)
{
// TODO: Add DeflaterOutputStream.Seek implementation
return(0);
}
public void Seek(int offset, SeekOrigin seekOrigin)
{
m_reader.BaseStream.Seek(offset, seekOrigin);
}
