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); }