public override int GetCharCount(byte[] bytes, int index, int count) { int result; try { result = defaultEncoding.GetDecoder().GetCharCount(bytes, index, count, true); } catch (DecoderFallbackException) { result = isoEncoding.GetDecoder().GetCharCount(bytes, index, count, true); } return(result); }
private void Init(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen) { _stream = stream; _encoding = encoding; _decoder = encoding.GetDecoder(); if (bufferSize < MinBufferSize) { bufferSize = MinBufferSize; } _byteBuffer = new byte[bufferSize]; _maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize); _charBuffer = new char[_maxCharsPerBuffer]; _byteLen = 0; _bytePos = 0; _detectEncoding = detectEncodingFromByteOrderMarks; // Encoding.GetPreamble() always allocates and returns a new byte[] array for // encodings that have a preamble. // We can avoid repeated allocations for the default and commonly used Encoding.UTF8 // encoding by using our own private cached instance of the UTF8 preamble. // We specifically look for Encoding.UTF8 because we know it has a preamble, // whereas other instances of UTF8Encoding may not have a preamble enabled, and // there's no public way to tell if the preamble is enabled for an instance other // than calling GetPreamble(), which we're trying to avoid. // This means that other instances of UTF8Encoding are excluded from this optimization. _preamble = object.ReferenceEquals(encoding, Encoding.UTF8) ? (s_utf8Preamble ?? (s_utf8Preamble = encoding.GetPreamble())) : encoding.GetPreamble(); _checkPreamble = (_preamble.Length > 0); _isBlocked = false; _closable = !leaveOpen; }
/// <summary> /// Create new C file access /// </summary> public CFile(Stream stream, Encoding encoding = null) { this._Stream = stream; EOF = _Stream == null; this._Encoding = encoding ?? Encoding.GetEncoding("Windows-1252"); this._Decoder = _Encoding.GetDecoder(); }
public BinaryReader(Stream input, Encoding encoding) { if (input == null) { throw new ArgumentNullException("input"); } if (encoding == null) { throw new ArgumentNullException("encoding"); } if (!input.CanRead) { throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotReadable")); } this.m_stream = input; this.m_decoder = encoding.GetDecoder(); this.m_maxCharsSize = encoding.GetMaxCharCount(0x80); int maxByteCount = encoding.GetMaxByteCount(1); if (maxByteCount < 0x10) { maxByteCount = 0x10; } this.m_buffer = new byte[maxByteCount]; this.m_charBuffer = null; this.m_charBytes = null; this.m_2BytesPerChar = encoding is UnicodeEncoding; this.m_isMemoryStream = this.m_stream.GetType() == typeof(MemoryStream); }
public HttpRequestStreamReader(Stream stream, Encoding encoding, int bufferSize) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (!stream.CanRead) { throw new ArgumentException(Resources.HttpRequestStreamReader_StreamNotReadable, nameof(stream)); } if (encoding == null) { throw new ArgumentNullException(nameof(encoding)); } _stream = stream; _encoding = encoding; _decoder = encoding.GetDecoder(); if (bufferSize < MinBufferSize) { bufferSize = MinBufferSize; } _byteBufferSize = bufferSize; _byteBuffer = new byte[bufferSize]; var maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize); _charBuffer = new char[maxCharsPerBuffer]; }
public ContentReader(Stream stream, long length, Encoding encoding = null) { _stream = stream; _length = length; if (encoding != null) { _decoder = encoding.GetDecoder(); } }
/// <summary> /// Constructs a new binary reader with the given bit converter, reading /// to the given stream, using the given encoding. /// </summary> /// <param name="bitConverter">Converter to use when reading data</param> /// <param name="stream">Stream to read data from</param> /// <param name="encoding">Encoding to use when reading character data</param> public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, Encoding encoding) { if (bitConverter == null) { throw new ArgumentNullException("bitConverter"); } if (stream == null) { throw new ArgumentNullException("stream"); } if (encoding == null) { throw new ArgumentNullException("encoding"); } if (!stream.CanRead) { throw new ArgumentException("Stream isn't writable", "stream"); } this.stream = stream; this.bitConverter = bitConverter; this.encoding = encoding; this.decoder = encoding.GetDecoder(); this.minBytesPerChar = 1; if (encoding is UnicodeEncoding) { minBytesPerChar = 2; } }
public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, System.Text.Encoding encoding) { this.disposed = false; this.buffer = new byte[0x10]; this.charBuffer = new char[1]; if (bitConverter == null) { throw new ArgumentNullException("bitConverter"); } if (stream == null) { throw new ArgumentNullException("stream"); } if (encoding == null) { throw new ArgumentNullException("encoding"); } if (!stream.CanRead) { throw new ArgumentException("Stream isn't writable", "stream"); } this.stream = stream; this.bitConverter = bitConverter; this.encoding = encoding; this.decoder = encoding.GetDecoder(); this.minBytesPerChar = 1; if (encoding is UnicodeEncoding) { this.minBytesPerChar = 2; } }
public BinaryReader(Stream input, Encoding encoding, bool leaveOpen) { if (input==null) { throw new ArgumentNullException(nameof(input)); } if (encoding==null) { throw new ArgumentNullException(nameof(encoding)); } if (!input.CanRead) throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotReadable")); Contract.EndContractBlock(); m_stream = input; m_decoder = encoding.GetDecoder(); m_maxCharsSize = encoding.GetMaxCharCount(MaxCharBytesSize); int minBufferSize = encoding.GetMaxByteCount(1); // max bytes per one char if (minBufferSize < 16) minBufferSize = 16; m_buffer = new byte[minBufferSize]; // m_charBuffer and m_charBytes will be left null. // For Encodings that always use 2 bytes per char (or more), // special case them here to make Read() & Peek() faster. m_2BytesPerChar = encoding is UnicodeEncoding; // check if BinaryReader is based on MemoryStream, and keep this for it's life // we cannot use "as" operator, since derived classes are not allowed m_isMemoryStream = (m_stream.GetType() == typeof(MemoryStream)); m_leaveOpen = leaveOpen; Contract.Assert(m_decoder!=null, "[BinaryReader.ctor]m_decoder!=null"); }
public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, System.Text.Encoding encoding) { this.disposed = false; this.buffer = new byte[0x10]; this.charBuffer = new char[1]; if (bitConverter == null) { throw new ArgumentNullException("bitConverter"); } if (stream == null) { throw new ArgumentNullException("stream"); } if (encoding == null) { throw new ArgumentNullException("encoding"); } if (!stream.CanRead) { throw new ArgumentException("Stream isn't writable", "stream"); } this.stream = stream; this.bitConverter = bitConverter; this.encoding = encoding; this.decoder = encoding.GetDecoder(); this.minBytesPerChar = 1; if (encoding is UnicodeEncoding) { this.minBytesPerChar = 2; } }
public EndianReader(Stream input, Endianness endianess, Encoding encoding, bool leaveOpen) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (encoding == null) { throw new ArgumentNullException(nameof(encoding)); } if (!input.CanRead) throw new ArgumentException("Can't read from the output stream", nameof(input)); Contract.EndContractBlock(); BaseStream = input; decoder = encoding.GetDecoder(); maxCharsSize = encoding.GetMaxCharCount(MaxCharBytesSize); var minBufferSize = encoding.GetMaxByteCount(1); // max bytes per one char if (minBufferSize < 16) minBufferSize = 16; buffer = new byte[minBufferSize]; // m_charBuffer and m_charBytes will be left null. // For Encodings that always use 2 bytes per char (or more), // special case them here to make Read() & Peek() faster. use2BytesPerChar = encoding is UnicodeEncoding; this.leaveOpen = leaveOpen; Endianness = endianess; resolvedEndianess = EndianessHelper.Resolve(endianess); Contract.Assert(decoder != null, "[EndianReader.ctor]m_decoder!=null"); }
public string DecodeByteToString(byte[] byteArray, System.Text.Encoding encoding) { char[] chars = new char[byteArray.Length + 1]; System.Text.Decoder d = encoding.GetDecoder(); int charLen = d.GetChars(byteArray, 0, byteArray.Length, chars, 0); return(new System.String(chars)); }
public PositionedStreamReader(Stream stream, Encoding encoding) { this.stream = stream; this.encoding = encoding; decoder = encoding.GetDecoder(); bufferpos = 0; readPosition = 0; }
public static string ConvertEncoding(string value, Encoding src, Encoding trg) { Decoder dec = src.GetDecoder(); byte[] ba = trg.GetBytes(value); int len = dec.GetCharCount(ba, 0, ba.Length); char[] ca = new char[len]; dec.GetChars(ba, 0, ba.Length, ca, 0); return new string(ca); }
TextSource(Encoding encoding) { _buffer = new Byte[BufferSize]; _chars = new Char[BufferSize + 1]; _raw = new MemoryStream(); _index = 0; _encoding = encoding ?? TextEncoding.Utf8; _decoder = _encoding.GetDecoder(); }
public AsyncLineReader(Stream stream, Encoding encoding, int bufferSize, int maxLineLength) { this.stream = stream; this.decoder = encoding.GetDecoder(); this.readBuffer = new byte[bufferSize]; this.decodeBuffer = new char[bufferSize]; this.maxLineLength = maxLineLength; StartRead(); }
public CancellableStreamReader(Stream stream, Encoding encoding) { _stream = stream; _decoder = encoding.GetDecoder(); _byteBuffer = new byte[BufferLength]; _buffer = new char[encoding.GetMaxCharCount(BufferLength)]; _bufferedLength = -1; _bufferCursor = -1; }
public AsyncTextReader(IAsyncDataSource dataSource, Encoding encoding, int bufferSize = DefaultBufferSize) : base() { _DataSource = dataSource; _Encoding = encoding; _Decoder = _Encoding.GetDecoder(); _BufferSize = Math.Max(MinimumBufferSize, bufferSize); AllocateBuffer(); }
public MiniStream (IMiniStreamSink sink, Encoding encoding, int buf_size) { if (sink == null) throw new ArgumentNullException (); this.sink = sink; this.sb = new StringBuilder (); this.decoder = encoding.GetDecoder (); this.buf = new char[buf_size]; }
public MyBinaryReader(Stream stream, Encoding encoding) : base(stream, encoding) { this.m_decoder = encoding.GetDecoder(); this.m_maxCharsSize = encoding.GetMaxCharCount(0x80); int maxByteCount = encoding.GetMaxByteCount(1); if (maxByteCount < 0x10) { maxByteCount = 0x10; } }
/// <summary>Initializes a new reusable reader.</summary> /// <param name="encoding">The Encoding to use. Defaults to UTF8.</param> /// <param name="bufferSize">The size of the buffer to use when reading from the stream.</param> public ReusableTextReader(Encoding encoding = null, int bufferSize = 1024) { if (encoding == null) { encoding = Encoding.UTF8; } _decoder = encoding.GetDecoder(); _bytes = new byte[bufferSize]; _chars = new char[encoding.GetMaxCharCount(_bytes.Length)]; }
public BinaryReader(Stream input, Encoding encoding) { if (input == null || encoding == null) throw new ArgumentNullException(Locale.GetText ("Input or Encoding is a null reference.")); if (!input.CanRead) throw new ArgumentException(Locale.GetText ("The stream doesn't support reading.")); m_stream = input; m_encoding = encoding; decoder = encoding.GetDecoder (); m_buffer = new byte [32]; }
internal DryadLinqBinaryReader(NativeBlockStream stream, Encoding encoding) { this.m_nativeStream = stream; this.m_encoding = encoding; this.m_decoder = encoding.GetDecoder(); this.m_curDataBlockInfo.DataBlock = null; this.m_curDataBlockInfo.BlockSize = -1; this.m_curDataBlockInfo.ItemHandle = IntPtr.Zero; this.m_curDataBlock = this.m_curDataBlockInfo.DataBlock; this.m_curBlockSize = this.m_curDataBlockInfo.BlockSize; this.m_curBlockPos = -1; this.m_isClosed = false; }
public static String convert(string sourceValue, Encoding source, Encoding target) { Encoder encoder = source.GetEncoder(); Decoder decoder = target.GetDecoder(); byte[] cpBytes = source.GetBytes(sourceValue); int bytesCount = source.GetByteCount(sourceValue); byte[] utfBytes = Encoding.Convert(source, target, cpBytes); char[] utfChars = new char[bytesCount]; decoder.GetChars(utfBytes, 0, utfBytes.Length, utfChars, 0); return new String(utfChars); }
static public int GetDecoder(IntPtr l) { try { System.Text.Encoding self = (System.Text.Encoding)checkSelf(l); var ret = self.GetDecoder(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
public BinaryReader(Stream input, Encoding encoding) { if (input == null || encoding == null) throw new ArgumentNullException(Locale.GetText ("Input or Encoding is a null reference.")); if (!input.CanRead) throw new ArgumentException(Locale.GetText ("The stream doesn't support reading.")); m_stream = input; m_encoding = encoding; decoder = encoding.GetDecoder (); // internal buffer size is documented to be between 16 and the value // returned by GetMaxByteCount for the specified encoding m_buffer = new byte [Math.Max (16, encoding.GetMaxByteCount (1))]; }
private CancellationTokenSource _disposalTokenSource; // Used to indicate that a cancellation is requested due to disposal internal SqlSequentialTextReader(SqlDataReader reader, int columnIndex, Encoding encoding) { Debug.Assert(reader != null, "Null reader when creating sequential textreader"); Debug.Assert(columnIndex >= 0, "Invalid column index when creating sequential textreader"); Debug.Assert(encoding != null, "Null encoding when creating sequential textreader"); _reader = reader; _columnIndex = columnIndex; _encoding = encoding; _decoder = encoding.GetDecoder(); _leftOverBytes = null; _peekedChar = -1; _currentTask = null; _disposalTokenSource = new CancellationTokenSource(); }
private void Init(Process process, Stream stream, UserCallBack callback, Encoding encoding, int bufferSize) { this.process = process; this.stream = stream; this.encoding = encoding; this.userCallBack = callback; decoder = encoding.GetDecoder(); if (bufferSize < MinBufferSize) bufferSize = MinBufferSize; byteBuffer = new byte[bufferSize]; _maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize); charBuffer = new char[_maxCharsPerBuffer]; cancelOperation = false; eofEvent = new ManualResetEvent(false); sb = null; this.bLastCarriageReturn = false; }
public TcpBinaryReader(Stream input, Encoding encoding) : base(input, encoding) { m_stream = input; this.m_decoder = encoding.GetDecoder(); this.m_maxCharsSize = encoding.GetMaxCharCount(0x80); int maxByteCount = encoding.GetMaxByteCount(1); if (maxByteCount < 0x10) { maxByteCount = 0x10; } this.m_buffer = new byte[maxByteCount]; this.m_2BytesPerChar = encoding is UnicodeEncoding; this.m_isMemoryStream = this.m_stream.GetType() == typeof(MemoryStream); }
internal NpgsqlBuffer(Stream underlying, int size, Encoding textEncoding) { if (size < MinimumBufferSize) { throw new ArgumentOutOfRangeException("size", size, "Buffer size must be at least " + MinimumBufferSize); } Contract.EndContractBlock(); Underlying = underlying; Size = size; _buf = new byte[Size]; TextEncoding = textEncoding; _textDecoder = TextEncoding.GetDecoder(); _textEncoder = TextEncoding.GetEncoder(); _tempCharBuf = new char[1024]; _workspace = new byte[8]; }
public static string ReadLine(this Stream stream, Encoding encoding = null) { encoding = encoding ?? Encoding.UTF8; var result = new StringBuilder(); var decoder = encoding.GetDecoder(); while (true) { var val = ReadMinimum(stream, decoder); if (val == null) throw new EndOfStreamException(); if (val == "\n") return result.ToString(); if (val != "\r") { result.Append(val); } } }
// If we're starting from the beginning of the file, we need to skip the BOM since it's // not part of the file. If we're starting partway through, there's no need to do that. // // It may seem strange allowing specifying the FileAccess, but it is useful as a safeguard // against other people already having the file open with e.g. FileAccess.Write and FileShare.Read. Utf8LineReader(string path, bool skipBOM, FileAccess access, FileShare share) { disposeStream = true; BaseStream = new FileStream(path, FileMode.Open, access, share); encoding = Encoding.UTF8; decoder = encoding.GetDecoder(); lineBuilder = new StringBuilder(); offset = 0; buffer = new byte[BufferSize]; bytesInBuffer = 0; Line = 0; if (skipBOM) SkipBOM(); }
/// <summary> /// Initializes an instance of DryadLinqTextReader. /// </summary> /// <param name="stream">A native stream to read from.</param> /// <param name="encoding">The text encoding.</param> public DryadLinqTextReader(NativeBlockStream stream, Encoding encoding) { this.m_nativeStream = stream; this.m_encoding = encoding; this.m_decoder = encoding.GetDecoder(); this.m_curDataBlockInfo.DataBlock = null; this.m_curDataBlockInfo.BlockSize = -1; this.m_curDataBlockInfo.ItemHandle = IntPtr.Zero; this.m_curBlockPos = 0; this.m_decodeUnitCharSize = this.m_encoding.GetMaxCharCount(DecodeUnitByteSize); this.m_charBuff = new char[this.m_decodeUnitCharSize + 2]; //allow 2 bytes for trailing newline this.m_charBuffEnd = 0; this.m_curLineStart = 0; this.m_curLineEnd = 0; this.m_isClosed = false; }
// Creates a new AsyncStreamReader for the given stream. The // character encoding is set by encoding and the buffer size, // in number of 16-bit characters, is set by bufferSize. internal AsyncStreamReader(Stream stream, Action<string> callback, Encoding encoding) { Debug.Assert(stream != null && encoding != null && callback != null, "Invalid arguments!"); Debug.Assert(stream.CanRead, "Stream must be readable!"); _stream = stream; _userCallBack = callback; _decoder = encoding.GetDecoder(); _byteBuffer = new byte[DefaultBufferSize]; // This is the maximum number of chars we can get from one iteration in loop inside ReadBuffer. // Used so ReadBuffer can tell when to copy data into a user's char[] directly, instead of our internal char[]. int maxCharsPerBuffer = encoding.GetMaxCharCount(DefaultBufferSize); _charBuffer = new char[maxCharsPerBuffer]; _cts = new CancellationTokenSource(); _messageQueue = new Queue<string>(); }
/// <summary> /// Decodes a URL, like System.Web.HttpUtility.UrlDecode /// </summary> /// <returns>The decoded URL</returns> /// <param name="value">The URL fragment to decode</param> /// <param name="encoding">The encoding to use</param> public static string UrlDecode(string value, System.Text.Encoding encoding = null) { if (value == null) { throw new ArgumentNullException(nameof(value)); } encoding = encoding ?? System.Text.Encoding.UTF8; var decoder = encoding.GetDecoder(); var inbuf = new byte[8]; var outbuf = new char[8]; return(RE_NUMBER.Replace(value, (m) => { if (m.Value == "+") { return " "; } try { var hex = m.Groups["number"].Value; var bytelen = hex.Length / 2; Utility.HexStringAsByteArray(hex, inbuf); var c = decoder.GetChars(inbuf, 0, bytelen, outbuf, 0); return new string(outbuf, 0, c); } catch { } //Fallback return m.Value; })); }