Encoder.cs

using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;

namespace System.Text
{
    [Serializable]
    [ComVisible(true)]
    [__DynamicallyInvokable]
    public abstract class Encoder
    {
        internal EncoderFallback m_fallback;

        [NonSerialized]
        internal EncoderFallbackBuffer m_fallbackBuffer;

        [ComVisible(false)]
        [__DynamicallyInvokable]
        public EncoderFallback Fallback
        {
            [__DynamicallyInvokable]
            get
            {
                return m_fallback;
            }
            [__DynamicallyInvokable]
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                if (m_fallbackBuffer != null && m_fallbackBuffer.Remaining > 0)
                {
                    throw new ArgumentException(Environment.GetResourceString("Argument_FallbackBufferNotEmpty"), "value");
                }
                m_fallback = value;
                m_fallbackBuffer = null;
            }
        }

        [ComVisible(false)]
        [__DynamicallyInvokable]
        public EncoderFallbackBuffer FallbackBuffer
        {
            [__DynamicallyInvokable]
            get
            {
                if (m_fallbackBuffer == null)
                {
                    if (m_fallback != null)
                    {
                        m_fallbackBuffer = m_fallback.CreateFallbackBuffer();
                    }
                    else
                    {
                        m_fallbackBuffer = EncoderFallback.ReplacementFallback.CreateFallbackBuffer();
                    }
                }
                return m_fallbackBuffer;
            }
        }

        internal bool InternalHasFallbackBuffer => m_fallbackBuffer != null;

        internal void SerializeEncoder(SerializationInfo info)
        {
            info.AddValue("m_fallback", m_fallback);
        }

        [__DynamicallyInvokable]
        protected Encoder()
        {
        }

        [ComVisible(false)]
        [__DynamicallyInvokable]
        public virtual void Reset()
        {
            char[] chars = new char[0];
            byte[] bytes = new byte[GetByteCount(chars, 0, 0, flush: true)];
            GetBytes(chars, 0, 0, bytes, 0, flush: true);
            if (m_fallbackBuffer != null)
            {
                m_fallbackBuffer.Reset();
            }
        }

        [__DynamicallyInvokable]
        public abstract int GetByteCount(char[] chars, int index, int count, bool flush);

        [SecurityCritical]
        [CLSCompliant(false)]
        [ComVisible(false)]
        public unsafe virtual int GetByteCount(char* chars, int count, bool flush)
        {
            if (chars == null)
            {
                throw new ArgumentNullException("chars", Environment.GetResourceString("ArgumentNull_Array"));
            }
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            }
            char[] array = new char[count];
            for (int i = 0; i < count; i++)
            {
                array[i] = chars[i];
            }
            return GetByteCount(array, 0, count, flush);
        }

        [__DynamicallyInvokable]
        public abstract int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush);

        [SecurityCritical]
        [CLSCompliant(false)]
        [ComVisible(false)]
        public unsafe virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
        {
            if (bytes == null || chars == null)
            {
                throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", Environment.GetResourceString("ArgumentNull_Array"));
            }
            if (charCount < 0 || byteCount < 0)
            {
                throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            }
            char[] array = new char[charCount];
            for (int i = 0; i < charCount; i++)
            {
                array[i] = chars[i];
            }
            byte[] array2 = new byte[byteCount];
            int bytes2 = GetBytes(array, 0, charCount, array2, 0, flush);
            if (bytes2 < byteCount)
            {
                byteCount = bytes2;
            }
            for (int i = 0; i < byteCount; i++)
            {
                bytes[i] = array2[i];
            }
            return byteCount;
        }

        [ComVisible(false)]
        [__DynamicallyInvokable]
        public virtual void Convert(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
        {
            if (chars == null || bytes == null)
            {
                throw new ArgumentNullException((chars == null) ? "chars" : "bytes", Environment.GetResourceString("ArgumentNull_Array"));
            }
            if (charIndex < 0 || charCount < 0)
            {
                throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            }
            if (byteIndex < 0 || byteCount < 0)
            {
                throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            }
            if (chars.Length - charIndex < charCount)
            {
                throw new ArgumentOutOfRangeException("chars", Environment.GetResourceString("ArgumentOutOfRange_IndexCountBuffer"));
            }
            if (bytes.Length - byteIndex < byteCount)
            {
                throw new ArgumentOutOfRangeException("bytes", Environment.GetResourceString("ArgumentOutOfRange_IndexCountBuffer"));
            }
            for (charsUsed = charCount; charsUsed > 0; charsUsed /= 2)
            {
                if (GetByteCount(chars, charIndex, charsUsed, flush) <= byteCount)
                {
                    bytesUsed = GetBytes(chars, charIndex, charsUsed, bytes, byteIndex, flush);
                    completed = (charsUsed == charCount && (m_fallbackBuffer == null || m_fallbackBuffer.Remaining == 0));
                    return;
                }
                flush = false;
            }
            throw new ArgumentException(Environment.GetResourceString("Argument_ConversionOverflow"));
        }

        [SecurityCritical]
        [CLSCompliant(false)]
        [ComVisible(false)]
        public unsafe virtual void Convert(char* chars, int charCount, byte* bytes, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
        {
            if (bytes == null || chars == null)
            {
                throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", Environment.GetResourceString("ArgumentNull_Array"));
            }
            if (charCount < 0 || byteCount < 0)
            {
                throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            }
            for (charsUsed = charCount; charsUsed > 0; charsUsed /= 2)
            {
                if (GetByteCount(chars, charsUsed, flush) <= byteCount)
                {
                    bytesUsed = GetBytes(chars, charsUsed, bytes, byteCount, flush);
                    completed = (charsUsed == charCount && (m_fallbackBuffer == null || m_fallbackBuffer.Remaining == 0));
                    return;
                }
                flush = false;
            }
            throw new ArgumentException(Environment.GetResourceString("Argument_ConversionOverflow"));
        }
    }
}