Decoder.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
 
namespace System.Text;
 
public abstract class Decoder
{
    internal DecoderFallback _fallback;
 
    internal DecoderFallbackBuffer _fallbackBuffer;
 
    public DecoderFallback? Fallback
    {
        get
        {
            return _fallback;
        }
        set
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }
            if (_fallbackBuffer != null && _fallbackBuffer.Remaining > 0)
            {
                throw new ArgumentException(SR.Argument_FallbackBufferNotEmpty, "value");
            }
            _fallback = value;
            _fallbackBuffer = null;
        }
    }
 
    public DecoderFallbackBuffer FallbackBuffer
    {
        get
        {
            if (_fallbackBuffer == null)
            {
                if (_fallback != null)
                {
                    _fallbackBuffer = _fallback.CreateFallbackBuffer();
                }
                else
                {
                    _fallbackBuffer = DecoderFallback.ReplacementFallback.CreateFallbackBuffer();
                }
            }
            return _fallbackBuffer;
        }
    }
 
    internal bool InternalHasFallbackBuffer => _fallbackBuffer != null;
 
    public virtual void Reset()
    {
        byte[] bytes = Array.Empty<byte>();
        char[] chars = new char[GetCharCount(bytes, 0, 0, flush: true)];
        GetChars(bytes, 0, 0, chars, 0, flush: true);
        _fallbackBuffer?.Reset();
    }
 
    public abstract int GetCharCount(byte[] bytes, int index, int count);
 
    public virtual int GetCharCount(byte[] bytes, int index, int count, bool flush)
    {
        return GetCharCount(bytes, index, count);
    }
 
    [CLSCompliant(false)]
    public unsafe virtual int GetCharCount(byte* bytes, int count, bool flush)
    {
        if (bytes == null)
        {
            throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
        }
        if (count < 0)
        {
            throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
        }
        byte[] array = new byte[count];
        for (int i = 0; i < count; i++)
        {
            array[i] = bytes[i];
        }
        return GetCharCount(array, 0, count);
    }
 
    public unsafe virtual int GetCharCount(ReadOnlySpan<byte> bytes, bool flush)
    {
        fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
        {
            return GetCharCount(bytes2, bytes.Length, flush);
        }
    }
 
    public abstract int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex);
 
    public virtual int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush)
    {
        return GetChars(bytes, byteIndex, byteCount, chars, charIndex);
    }
 
    [CLSCompliant(false)]
    public unsafe virtual int GetChars(byte* bytes, int byteCount, char* chars, int charCount, bool flush)
    {
        if (chars == null || bytes == null)
        {
            throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
        }
        if (byteCount < 0 || charCount < 0)
        {
            throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
        }
        byte[] array = new byte[byteCount];
        for (int i = 0; i < byteCount; i++)
        {
            array[i] = bytes[i];
        }
        char[] array2 = new char[charCount];
        int chars2 = GetChars(array, 0, byteCount, array2, 0, flush);
        if (chars2 < charCount)
        {
            charCount = chars2;
        }
        for (int i = 0; i < charCount; i++)
        {
            chars[i] = array2[i];
        }
        return charCount;
    }
 
    public unsafe virtual int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars, bool flush)
    {
        fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
        {
            fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
            {
                return GetChars(bytes2, bytes.Length, chars2, chars.Length, flush);
            }
        }
    }
 
    public virtual void Convert(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, int charCount, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
    {
        if (bytes == null || chars == null)
        {
            throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
        }
        if (byteIndex < 0 || byteCount < 0)
        {
            throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
        }
        if (charIndex < 0 || charCount < 0)
        {
            throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
        }
        if (bytes.Length - byteIndex < byteCount)
        {
            throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
        }
        if (chars.Length - charIndex < charCount)
        {
            throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
        }
        for (bytesUsed = byteCount; bytesUsed > 0; bytesUsed /= 2)
        {
            if (GetCharCount(bytes, byteIndex, bytesUsed, flush) <= charCount)
            {
                charsUsed = GetChars(bytes, byteIndex, bytesUsed, chars, charIndex, flush);
                completed = bytesUsed == byteCount && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
                return;
            }
            flush = false;
        }
        throw new ArgumentException(SR.Argument_ConversionOverflow);
    }
 
    [CLSCompliant(false)]
    public unsafe virtual void Convert(byte* bytes, int byteCount, char* chars, int charCount, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
    {
        if (chars == null || bytes == null)
        {
            throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
        }
        if (byteCount < 0 || charCount < 0)
        {
            throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
        }
        for (bytesUsed = byteCount; bytesUsed > 0; bytesUsed /= 2)
        {
            if (GetCharCount(bytes, bytesUsed, flush) <= charCount)
            {
                charsUsed = GetChars(bytes, bytesUsed, chars, charCount, flush);
                completed = bytesUsed == byteCount && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
                return;
            }
            flush = false;
        }
        throw new ArgumentException(SR.Argument_ConversionOverflow);
    }
 
    public unsafe virtual void Convert(ReadOnlySpan<byte> bytes, Span<char> chars, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
    {
        fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
        {
            fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
            {
                Convert(bytes2, bytes.Length, chars2, chars.Length, flush, out bytesUsed, out charsUsed, out completed);
            }
        }
    }
}