public static void Skip(this Stream stream, long count, int buffSize, bool readMethod) { if (stream == null) { throw new ArgumentNullException("stream"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (buffSize <= 0) { throw new ArgumentOutOfRangeException("bufferSize"); } if (count == 0) { return; } if (!readMethod) { stream.Position += count; return; } byte[] buffer = new byte[Comparable.Min(count, buffSize)]; while (count > 0) { int read = stream.Read(buffer, 0, (int)Comparable.Min(count, buffer.Length)); if (read == 0) { break; } count -= read; } }
public static SqlChars ReadSqlChars(this StreamReader streamReader, Int64 count) { if (streamReader == null) { throw new ArgumentNullException("streamReader"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } SqlChars chars = new SqlChars(new char[count]); var buffer = new char[Comparable.Min(SqlRuntime.IoBufferSize, count)]; long offset = 0L; chars.SetLength(0); while (!streamReader.EndOfStream && count > 0) { int read = streamReader.ReadBlock(buffer, 0, (int)Comparable.Min(buffer.Length, count)); chars.SetLength(offset + read); chars.Write(offset, buffer, 0, read); offset += read; count -= read; } return(chars); }
public override Int32 Read(Byte[] buffer, Int32 offset, Int32 count) { if (_ptr == IntPtr.Zero) { throw new ObjectDisposedException(null); } if (buffer == null) { throw new ArgumentNullException("buffer"); } if (offset < 0 || offset >= buffer.Length) { throw new ArgumentOutOfRangeException("offset"); } if (count < 0 || count > buffer.Length - offset) { throw new ArgumentOutOfRangeException("count"); } if (_length >= 0) { count = (int)Comparable.Min(_length - _position, count); } if (count > 0) { Marshal.Copy(new IntPtr(_ptr.ToInt64() + _offset + _position), buffer, offset, count); _position += count; } return(count); }
public static SqlBytes ReadSqlBytes(this Stream stream, Int64 count) { if (stream == null) { throw new ArgumentNullException("stream"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } var bytes = new SqlBytes(new byte[count]); var buffer = new byte[Comparable.Min(SqlRuntime.IoBufferSize, count)]; long index = 0L; bytes.SetLength(0); while (count > 0) { int read = stream.Read(buffer, 0, (int)Comparable.Min(buffer.Length, count)); if (read == 0) { break; } bytes.SetLength(index + read); bytes.Write(index, buffer, 0, read); index += read; count -= read; } return(bytes); }
public static void WriteSqlChars(this Stream stream, SqlChars chars, Encoding encoding) { if (stream == null) { throw new ArgumentNullException("stream"); } if (chars == null) { throw new ArgumentNullException("chars"); } if (encoding == null) { throw new ArgumentNullException("encoding"); } long count = chars.Length; var buffer = new char[Comparable.Min(SqlRuntime.IoBufferSize, count)]; long index = 0L; while (count > 0) { int read = (int)chars.Read(index, buffer, 0, (int)Comparable.Min(buffer.Length, count)); stream.WriteChars(buffer.AsEnumerable(), encoding); index += read; count -= read; } }
public override void Write(byte[] buffer, int offset, int count) { _stream.Write(buffer, offset, count); if (count == 0) { return; } try { long position = _stream.Position; if (position == _position + count) { if (count > _buffer.Capacity - _buffer.Count) { _buffer.RemoveRange(0, Comparable.Min(count - (_buffer.Capacity - _buffer.Count), _buffer.Count)); } _buffer.AddRange(buffer.Skip(offset + Comparable.Max(count - _buffer.Capacity, 0)).Take(Comparable.Min(count, _buffer.Capacity - _buffer.Count))); _position = position; _offset = _buffer.Count; } } catch (NotSupportedException) { } }
public override int Read(byte[] buffer, int offset, int count) { try { long position = _stream.Position; if (position != _position - (_buffer.Count - _offset)) { _buffer.Clear(); _offset = _buffer.Count; _position = position; } } catch (NotSupportedException) { } int cached = Comparable.Min(count, _buffer.Count - _offset); if (cached > 0) { //buffer.MoveRange(); buffer.Fill(i => _buffer[_offset + i], new Range(offset, cached)); } int read = count - cached; if (read > 0) { read = _stream.Read(buffer, offset, read); if (read > _buffer.Capacity - _buffer.Count) { _buffer.RemoveRange(0, Comparable.Min(read - (_buffer.Capacity - _buffer.Count), _buffer.Count)); } _buffer.AddRange(buffer.Skip(offset + cached + Comparable.Max(0, read - (_buffer.Capacity - _buffer.Count))).Take(Comparable.Min(read, _buffer.Capacity - _buffer.Count))); } return(cached + read); }
public void SetRange(SqlInt64Array array, SqlInt32 index) { if (array.IsNull) { return; } int indexValue = index.IsNull ? _array.Length - Comparable.Min(_array.Length, array._array.Length) : index.Value; _array.Fill(i => array._array[i - indexValue]); }
public void SetRange(SqlInt32 index, SqlHourAngleCollection range) { if (range.IsNull) { return; } int indexValue = index.IsNull ? _list.Count - Comparable.Min(_list.Count, range._list.Count) : index.Value; _list.SetRange(indexValue, range.List); }
public override int Read(byte[] buffer, int offset, int count) { if (_available == 0 || count == 0) { return(0); } int read = _stream.Read(buffer, offset, (int)Comparable.Min(_available, count)); _available -= read; return(read); }
public override void Write(byte[] buffer, int offset, int count) { if (count > _available) { throw new InvalidOperationException("Exceeded write operation limit."); } if (_available > 0 && count > 0) { int write = (int)Comparable.Min(_available, count); _stream.Write(buffer, offset, write); _available -= write; } }
private static void Copy(SqlBytes source, long srcOffset, SqlBytes destination, long dstOffset, long length) { if (length == 0) { return; } byte[] buffer = new byte[Comparable.Min(SqlRuntime.IoBufferSize, length)]; long read = 0; while (length > 0 && (read = source.Read(srcOffset, buffer, 0, (int)Comparable.Min(length, buffer.Length))) > 0L) { destination.Write(dstOffset, buffer, 0, (int)read); length -= read; srcOffset += read; dstOffset += read; } }
public static int Compare(this Stream xStream, Stream yStream, long count, int buffSize, Comparison <byte> comparison) { if (xStream == null) { throw new ArgumentNullException("xStream"); } if (yStream == null) { throw new ArgumentNullException("yStream"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (buffSize <= 0) { throw new ArgumentOutOfRangeException("buffSize"); } if (comparison == null) { comparison = Comparer <byte> .Default.Compare; } byte[] xBuffer = new byte[buffSize]; byte[] yBuffer = new byte[buffSize]; long total = 0; int xRead, yRead, result; do { xRead = xStream.Read(xBuffer, 0, (int)Comparable.Min(xBuffer.Length, count - total)); yRead = yStream.Read(yBuffer, 0, (int)Comparable.Min(yBuffer.Length, count - total)); result = xBuffer.Take(xRead).SequenceCompare(yBuffer.Take(yRead), comparison); if (result == 0) { total += Comparable.Max(xRead, yRead); } }while (result == 0 && xRead > 0 && yRead > 0 && total < count); return(result); }
public static void WriteSqlBytes(this Stream stream, SqlBytes bytes) { if (stream == null) { throw new ArgumentNullException("stream"); } if (bytes == null) { throw new ArgumentNullException("bytes"); } long count = bytes.Length; var buffer = new byte[Comparable.Min(SqlRuntime.IoBufferSize, count)]; long index = 0L; while (count > 0) { int read = (int)bytes.Read(index, buffer, 0, (int)Comparable.Min(buffer.Length, count)); stream.Write(buffer, 0, read); index += read; count -= read; } }
public static void WriteSqlChars(this StreamWriter streamWriter, SqlChars chars) { if (streamWriter == null) { throw new ArgumentNullException("streamWriter"); } if (chars == null) { throw new ArgumentNullException("chars"); } long count = chars.Length; var buffer = new char[Comparable.Min(SqlRuntime.IoBufferSize, count)]; long index = 0L; while (count > 0) { int read = (int)chars.Read(index, buffer, 0, (int)Comparable.Min(buffer.Length, count)); streamWriter.Write(buffer, 0, read); index += read; count -= read; } }
public static SqlChars ReadSqlChars(this Stream stream, Encoding encoding, Int64 count) { if (stream == null) { throw new ArgumentNullException("stream"); } if (encoding == null) { throw new ArgumentNullException("encoding"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } SqlChars chars = new SqlChars(new char[count]); var buffer = new char[Comparable.Min(SqlRuntime.IoBufferSize, count)]; using (var e = stream.ReadChars(encoding).Take(count).GetEnumerator()) { long offset = 0L; int read = 0; chars.SetLength(0); do { read = buffer.Fill(e); if (read > 0) { chars.SetLength(offset + read); chars.Write(offset, buffer, 0, read); offset += read; } }while (read == buffer.Length); } return(chars); }
public static SqlBoolean EqualRange(SqlBytes xData, SqlInt64 xIndex, SqlBytes yData, SqlInt64 yIndex, SqlInt64 count) { if (xData.IsNull || yData.IsNull) { return(SqlBoolean.Null); } long xIndexValue = !xIndex.IsNull ? xIndex.Value : count.IsNull ? 0 : xData.Length - Comparable.Min(count.Value, xData.Length); long yIndexValue = !yIndex.IsNull ? yIndex.Value : count.IsNull ? 0 : yData.Length - Comparable.Min(count.Value, yData.Length); long countValue = !count.IsNull ? count.Value : int.MaxValue; return(xData.Buffer.SequenceEqual((int)xIndexValue, yData.Buffer, (int)yIndexValue, (int)countValue)); }
public SqlChars ReadTextByCpName(SqlInt64 offset, SqlInt64 count, SqlBoolean detectEncoding, [SqlFacet(MaxSize = 128)] SqlString cpName) { if (IsNull) { return(SqlChars.Null); } var fileEncoding = cpName.IsNull ? SqlRuntime.FileEncoding : Encoding.GetEncoding(cpName.Value); using (var fs = _fi.OpenRead()) { if (detectEncoding.IsTrue) { var preamble = EncodingPreamble.Detect(fs.ReadBytesMost(1, 4) ?? new byte[0]); if (preamble != null) { fileEncoding = Encoding.GetEncoding(preamble.CodePage); } else { fs.Position = 0; } } if (!offset.IsNull) { fs.Position = offset.Value; } return(fs.ReadSqlChars(fileEncoding, !count.IsNull ? count.Value : (fs.Length - fs.Position).Yield(t => (int)Comparable.Min(t, int.MaxValue), (t, r) => t - r, t => t > 0).Aggregate(0L, (t, p) => t + fileEncoding.GetMaxCharCount(p)))); } }
public SqlChars ReadAllTextByCpId(SqlBoolean detectEncoding, SqlInt32 cpId) { if (IsNull) { return(SqlChars.Null); } var fileEncoding = cpId.IsNull ? SqlRuntime.FileEncoding : Encoding.GetEncoding(cpId.Value); using (var fs = _fi.OpenRead()) { if (detectEncoding.IsTrue) { var preamble = EncodingPreamble.Detect(fs.ReadBytesMost(1, 4) ?? new byte[0]); if (preamble != null) { fileEncoding = Encoding.GetEncoding(preamble.CodePage); } else { fs.Position = 0; } } return(fs.ReadSqlChars(fileEncoding, (fs.Length - fs.Position).Yield(t => (int)Comparable.Min(t, int.MaxValue), (t, r) => t - r, t => t > 0).Aggregate(0L, (t, p) => t + fileEncoding.GetMaxCharCount(p)))); } }
public static long Move(this Stream stream, long destination, long count, int buffSize, ExpandMethod expandMethod, IProgress <long> progress, long unitSize) { if (stream == null) { throw new ArgumentNullException("stream"); } long source = stream.Position; if (destination < 0) { throw new ArgumentOutOfRangeException("destination"); } if (count < 0 || count > stream.Length - source) { throw new ArgumentOutOfRangeException("count"); } if (buffSize <= 0) { throw new ArgumentOutOfRangeException("bufferSize"); } if (unitSize < 0) { throw new ArgumentOutOfRangeException("unitSize"); } bool reverse = source < destination; long total = 0L; long before = 0L; int read; byte[] buffer = new byte[buffSize]; if (reverse) { if (stream.Length < destination + count) { switch (expandMethod) { case ExpandMethod.SetLength: stream.SetLength(destination + count); break; case ExpandMethod.WriteZero: { stream.Position = stream.Length; long length = destination + count - stream.Length; while (length > 0L) { int block = (int)Comparable.Min(length, (long)filler.Length); stream.Write(filler, 0, block); length -= block; } } break; } } stream.Position = source + count - Comparable.Min(count, buffer.Length); } while (total < count && (read = stream.Read(buffer, 0, (int)Comparable.Min(count - total, buffer.Length))) > 0) { stream.Position = destination + (reverse ? count - total - read : total); stream.Write(buffer, 0, read); stream.Position = source + (reverse ? count - total - read : total); total += read; if (progress != null && total - before >= unitSize) { before = total; progress.Report(total); } } return(total); }
public static long Copy(this Stream srcStream, Stream dstStream, long count, int buffSize, IProgress <long> progress, long unitSize) { if (srcStream == null) { throw new ArgumentNullException("srcStream"); } if (dstStream == null) { throw new ArgumentNullException("dstStream"); } if (srcStream == dstStream) { throw new ArgumentException("Both streams are same"); } if (buffSize <= 0) { throw new ArgumentOutOfRangeException("buffSize"); } if (unitSize < 0) { throw new ArgumentOutOfRangeException("unitSize"); } if (!srcStream.CanRead) { if (!srcStream.CanWrite) { throw new ObjectDisposedException("srcStream"); } else { throw new NotSupportedException(); } } if (!dstStream.CanWrite) { if (!dstStream.CanRead) { throw new ObjectDisposedException(null); } else { throw new NotSupportedException("dstStream"); } } long total = 0; long before = 0; int read; byte[] buffer = new byte[buffSize]; while (total < count && (read = srcStream.Read(buffer, 0, (int)Comparable.Min(count - total, buffer.Length))) != 0) { dstStream.Write(buffer, 0, read); total += read; if (progress != null && total - before >= unitSize) { before = total; progress.Report(total); } } return(total); }