private string GetUnicodeCharsText()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Unicode, "");
return(_bufferReader.GetUnicodeString(_offset, _length));
}
private void GetBase64(byte[] buffer, int offset, int count)
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Base64, "");
_bufferReader.GetBase64(_offset, buffer, offset, count);
}
public void SetValue(PrefixHandleType type)
{
DiagnosticUtility.DebugAssert(type != PrefixHandleType.Buffer, "");
_type = type;
}
private double GetDouble()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Double, "");
return(_bufferReader.GetDouble(_offset));
}
private UniqueId GetUniqueId()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.UniqueId, "");
return(_bufferReader.GetUniqueId(_offset));
}
private int GetInt32()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Int32, "");
return(_bufferReader.GetInt32(_offset));
}
private ulong GetUInt64()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.UInt64, "");
return(_bufferReader.GetUInt64(_offset));
}
protected void WriteByte(char ch)
{
DiagnosticUtility.DebugAssert(ch < 0x80, "");
WriteByte((byte)ch);
}
protected Task WriteByteAsync(char ch)
{
DiagnosticUtility.DebugAssert(ch < 0x80, "");
return(WriteByteAsync((byte)ch));
}
public bool TryReadChars(char[] chars, int offset, int count, out int actual)
{
DiagnosticUtility.DebugAssert(offset + count <= chars.Length, string.Format("offset '{0}' + count '{1}' MUST BE <= chars.Length '{2}'", offset, count, chars.Length));
if (_type == ValueHandleType.Unicode)
{
return(TryReadUnicodeChars(chars, offset, count, out actual));
}
if (_type != ValueHandleType.UTF8)
{
actual = 0;
return(false);
}
int charOffset = offset;
int charCount = count;
byte[] bytes = _bufferReader.Buffer;
int byteOffset = _offset;
int byteCount = _length;
bool insufficientSpaceInCharsArray = false;
var encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
while (true)
{
while (charCount > 0 && byteCount > 0)
{
// fast path for codepoints U+0000 - U+007F
byte b = bytes[byteOffset];
if (b >= 0x80)
{
break;
}
chars[charOffset] = (char)b;
byteOffset++;
byteCount--;
charOffset++;
charCount--;
}
if (charCount == 0 || byteCount == 0 || insufficientSpaceInCharsArray)
{
break;
}
int actualByteCount;
int actualCharCount;
try
{
// If we're asking for more than are possibly available, or more than are truly available then we can return the entire thing
if (charCount >= encoding.GetMaxCharCount(byteCount) || charCount >= encoding.GetCharCount(bytes, byteOffset, byteCount))
{
actualCharCount = encoding.GetChars(bytes, byteOffset, byteCount, chars, charOffset);
actualByteCount = byteCount;
}
else
{
Decoder decoder = encoding.GetDecoder();
// Since x bytes can never generate more than x characters this is a safe estimate as to what will fit
actualByteCount = Math.Min(charCount, byteCount);
// We use a decoder so we don't error if we fall across a character boundary
actualCharCount = decoder.GetChars(bytes, byteOffset, actualByteCount, chars, charOffset);
// We might have gotten zero characters though if < 4 bytes were requested because
// codepoints from U+0000 - U+FFFF can be up to 3 bytes in UTF-8, and represented as ONE char
// codepoints from U+10000 - U+10FFFF (last Unicode codepoint representable in UTF-8) are represented by up to 4 bytes in UTF-8
// and represented as TWO chars (high+low surrogate)
// (e.g. 1 char requested, 1 char in the buffer represented in 3 bytes)
while (actualCharCount == 0)
{
// Note the by the time we arrive here, if actualByteCount == 3, the next decoder.GetChars() call will read the 4th byte
// if we don't bail out since the while loop will advance actualByteCount only after reading the byte.
if (actualByteCount >= 3 && charCount < 2)
{
// If we reach here, it means that we're:
// - trying to decode more than 3 bytes and,
// - there is only one char left of charCount where we're stuffing decoded characters.
// In this case, we need to back off since decoding > 3 bytes in UTF-8 means that we will get 2 16-bit chars
// (a high surrogate and a low surrogate) - the Decoder will attempt to provide both at once
// and an ArgumentException will be thrown complaining that there's not enough space in the output char array.
// actualByteCount = 0 when the while loop is broken out of; decoder goes out of scope so its state no longer matters
insufficientSpaceInCharsArray = true;
break;
}
else
{
DiagnosticUtility.DebugAssert(byteOffset + actualByteCount < bytes.Length,
string.Format("byteOffset {0} + actualByteCount {1} MUST BE < bytes.Length {2}", byteOffset, actualByteCount, bytes.Length));
// Request a few more bytes to get at least one character
actualCharCount = decoder.GetChars(bytes, byteOffset + actualByteCount, 1, chars, charOffset);
actualByteCount++;
}
}
// Now that we actually retrieved some characters, figure out how many bytes it actually was
actualByteCount = encoding.GetByteCount(chars, charOffset, actualCharCount);
}
}
catch (FormatException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateEncodingException(bytes, byteOffset, byteCount, exception));
}
// Advance
byteOffset += actualByteCount;
byteCount -= actualByteCount;
charOffset += actualCharCount;
charCount -= actualCharCount;
}
_offset = byteOffset;
_length = byteCount;
actual = (count - charCount);
return(true);
}
protected void Advance(int count)
{
DiagnosticUtility.DebugAssert(_offset + count <= bufferLength, "");
_offset += count;
}
public string GetString()
{
ValueHandleType type = _type;
if (type == ValueHandleType.UTF8)
{
return(GetCharsText());
}
switch (type)
{
case ValueHandleType.False:
return("false");
case ValueHandleType.True:
return("true");
case ValueHandleType.Zero:
return("0");
case ValueHandleType.One:
return("1");
case ValueHandleType.Int8:
case ValueHandleType.Int16:
case ValueHandleType.Int32:
return(XmlConverter.ToString(ToInt()));
case ValueHandleType.Int64:
return(XmlConverter.ToString(GetInt64()));
case ValueHandleType.UInt64:
return(XmlConverter.ToString(GetUInt64()));
case ValueHandleType.Single:
return(XmlConverter.ToString(GetSingle()));
case ValueHandleType.Double:
return(XmlConverter.ToString(GetDouble()));
case ValueHandleType.Decimal:
return(XmlConverter.ToString(GetDecimal()));
case ValueHandleType.DateTime:
return(XmlConverter.ToString(ToDateTime()));
case ValueHandleType.Empty:
return(string.Empty);
case ValueHandleType.Unicode:
return(GetUnicodeCharsText());
case ValueHandleType.EscapedUTF8:
return(GetEscapedCharsText());
case ValueHandleType.Char:
return(GetCharText());
case ValueHandleType.Dictionary:
return(GetDictionaryString().Value);
case ValueHandleType.Base64:
byte[] bytes = ToByteArray();
DiagnosticUtility.DebugAssert(bytes != null, "");
return(Base64Encoding.GetString(bytes, 0, bytes.Length));
case ValueHandleType.List:
return(XmlConverter.ToString(ToList()));
case ValueHandleType.UniqueId:
return(XmlConverter.ToString(ToUniqueId()));
case ValueHandleType.Guid:
return(XmlConverter.ToString(ToGuid()));
case ValueHandleType.TimeSpan:
return(XmlConverter.ToString(ToTimeSpan()));
case ValueHandleType.QName:
return(GetQNameDictionaryText());
case ValueHandleType.ConstString:
return(s_constStrings[_offset]);
default:
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException());
}
}
private string GetQNameDictionaryText()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.QName, "");
return(string.Concat(PrefixHandle.GetString(PrefixHandle.GetAlphaPrefix(_length)), ":", _bufferReader.GetDictionaryString(_offset)));
}
private XmlDictionaryString GetDictionaryString()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Dictionary, "");
return(_bufferReader.GetDictionaryString(_offset));
}
private string GetEscapedCharsText()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.EscapedUTF8, "");
return(_bufferReader.GetEscapedString(_offset, _length));
}
protected void WriteBytes(char ch1, char ch2)
{
DiagnosticUtility.DebugAssert(ch1 < 0x80 && ch2 < 0x80, "");
WriteBytes((byte)ch1, (byte)ch2);
}
private int GetChar()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Char, "");
return(_offset);
}
protected Task WriteBytesAsync(char ch1, char ch2)
{
DiagnosticUtility.DebugAssert(ch1 < 0x80 && ch2 < 0x80, "");
return(WriteBytesAsync((byte)ch1, (byte)ch2));
}
private long GetInt64()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Int64 || _type == ValueHandleType.TimeSpan || _type == ValueHandleType.DateTime, "");
return(_bufferReader.GetInt64(_offset));
}
public void Advance(int count)
{
DiagnosticUtility.DebugAssert(_offset + count <= _offsetMax, "");
_offset += count;
}
private float GetSingle()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Single, "");
return(_bufferReader.GetSingle(_offset));
}
public static string GetString(PrefixHandleType type)
{
DiagnosticUtility.DebugAssert(type != PrefixHandleType.Buffer, "");
return(s_prefixStrings[(int)type]);
}
private decimal GetDecimal()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Decimal, "");
return(_bufferReader.GetDecimal(_offset));
}
public static PrefixHandleType GetAlphaPrefix(int index)
{
DiagnosticUtility.DebugAssert(index >= 0 && index < 26, "");
return((PrefixHandleType)(PrefixHandleType.A + index));
}
private Guid GetGuid()
{
DiagnosticUtility.DebugAssert(_type == ValueHandleType.Guid, "");
return(_bufferReader.GetGuid(_offset));
}
public void ToPrefixHandle(PrefixHandle prefix)
{
DiagnosticUtility.DebugAssert(_type == StringHandleType.UTF8, "");
prefix.SetValue(_offset, _length);
}