CopyTo()

unsafe void System.Collections.BitArray.CopyTo ( Array array, int index )

inline

Implements System.Collections.ICollection.

Definition at line 820 of file BitArray.cs.

    {
        if (array == null)
        {
            throw new ArgumentNullException("array");
        }
        if (index < 0)
        {
            throw new ArgumentOutOfRangeException("index", index, System.SR.ArgumentOutOfRange_NeedNonNegNum);
        }
        if (array.Rank != 1)
        {
            throw new ArgumentException(System.SR.Arg_RankMultiDimNotSupported, "array");
        }
        if (array is int[] array2)
        {
            Div32Rem(m_length, out var remainder);
            if (remainder == 0)
            {
                Array.Copy(m_array, 0, array2, index, m_array.Length);
                return;
            }
            int num = m_length - 1 >> 5;
            Array.Copy(m_array, 0, array2, index, num);
            array2[index + num] = m_array[num] & ((1 << remainder) - 1);
            return;
        }
        if (array is byte[] array3)
        {
            int num2 = GetByteArrayLengthFromBitLength(m_length);
            if (array.Length - index < num2)
            {
                throw new ArgumentException(System.SR.Argument_InvalidOffLen);
            }
            uint num3 = (uint)m_length & 7u;
            if (num3 != 0)
            {
                num2--;
            }
            Span<byte> destination = array3.AsSpan(index);
            int remainder2;
            int num4 = Div4Rem(num2, out remainder2);
            for (int i = 0; i < num4; i++)
            {
                BinaryPrimitives.WriteInt32LittleEndian(destination, m_array[i]);
                destination = destination.Slice(4);
            }
            if (num3 != 0)
            {
                destination[remainder2] = (byte)((m_array[num4] >> remainder2 * 8) & ((1 << (int)num3) - 1));
            }
            switch (remainder2)
            {
            default:
                return;
            case 3:
                destination[2] = (byte)(m_array[num4] >> 16);
                goto case 2;
            case 2:
                destination[1] = (byte)(m_array[num4] >> 8);
                break;
            case 1:
                break;
            }
            destination[0] = (byte)m_array[num4];
            return;
        }
        if (array is bool[] array4)
        {
            if (array.Length - index < m_length)
            {
                throw new ArgumentException(System.SR.Argument_InvalidOffLen);
            }
            uint num5 = 0u;
            if (m_length >= 32)
            {
                Vector128<byte> vector = Vector128.Create(0L, 72340172838076673L).AsByte();
                Vector128<byte> vector2 = Vector128.Create(144680345676153346L, 217020518514230019L).AsByte();
                if (Avx2.IsSupported)
                {
                    Vector256<byte> mask = Vector256.Create(vector, vector2);
                    Vector256<byte> right = Vector256.Create(9241421688590303745uL).AsByte();
                    Vector256<byte> right2 = Vector256.Create((byte)1);
                    fixed (bool* ptr = &array4[index])
                    {
                        for (; num5 + 32 <= (uint)m_length; num5 += 32)
                        {
                            int value = m_array[num5 / 32];
                            Vector256<int> vector3 = Vector256.Create(value);
                            Vector256<byte> left = Avx2.Shuffle(vector3.AsByte(), mask);
                            Vector256<byte> left2 = Avx2.And(left, right);
                            Vector256<byte> source = Avx2.Min(left2, right2);
                            Avx.Store((byte*)(ptr + num5), source);
                        }
                    }
                }
                else if (Ssse3.IsSupported)
                {
                    Vector128<byte> mask2 = vector;
                    Vector128<byte> mask3 = vector2;
                    Vector128<byte> right3 = Vector128.Create((byte)1);
                    Vector128<byte> right4 = (BitConverter.IsLittleEndian ? Vector128.Create(9241421688590303745uL).AsByte() : Vector128.Create(72624976668147840L).AsByte());
                    fixed (bool* ptr2 = &array4[index])
                    {
                        for (; num5 + 32 <= (uint)m_length; num5 += 32)
                        {
                            int value2 = m_array[num5 / 32];
                            Vector128<int> vector4 = Vector128.CreateScalarUnsafe(value2);
                            Vector128<byte> left3 = Ssse3.Shuffle(vector4.AsByte(), mask2);
                            Vector128<byte> left4 = Sse2.And(left3, right4);
                            Vector128<byte> source2 = Sse2.Min(left4, right3);
                            Sse2.Store((byte*)(ptr2 + num5), source2);
                            Vector128<byte> left5 = Ssse3.Shuffle(vector4.AsByte(), mask3);
                            Vector128<byte> left6 = Sse2.And(left5, right4);
                            Vector128<byte> source3 = Sse2.Min(left6, right3);
                            Sse2.Store((byte*)(ptr2 + num5 + Vector128<byte>.Count), source3);
                        }
                    }
                }
                else if (AdvSimd.IsSupported)
                {
                    Vector128<byte> right5 = Vector128.Create((byte)1);
                    Vector128<byte> right6 = (BitConverter.IsLittleEndian ? Vector128.Create(9241421688590303745uL).AsByte() : Vector128.Create(72624976668147840L).AsByte());
                    fixed (bool* ptr3 = &array4[index])
                    {
                        for (; num5 + 32 <= (uint)m_length; num5 += 32)
                        {
                            int value3 = m_array[num5 / 32];
                            if (!BitConverter.IsLittleEndian)
                            {
                                value3 = BinaryPrimitives.ReverseEndianness(value3);
                            }
                            Vector128<byte> vector5 = Vector128.Create(value3).AsByte();
                            vector5 = AdvSimd.Arm64.ZipLow(vector5, vector5);
                            vector5 = AdvSimd.Arm64.ZipLow(vector5, vector5);
                            Vector128<byte> left7 = AdvSimd.Arm64.ZipLow(vector5, vector5);
                            Vector128<byte> left8 = AdvSimd.And(left7, right6);
                            Vector128<byte> source4 = AdvSimd.Min(left8, right5);
                            AdvSimd.Store((byte*)(ptr3 + num5), source4);
                            Vector128<byte> left9 = AdvSimd.Arm64.ZipHigh(vector5, vector5);
                            Vector128<byte> left10 = AdvSimd.And(left9, right6);
                            Vector128<byte> source5 = AdvSimd.Min(left10, right5);
                            AdvSimd.Store((byte*)(ptr3 + num5 + Vector128<byte>.Count), source5);
                        }
                    }
                }
            }
            for (; num5 < (uint)m_length; num5++)
            {
                int remainder3;
                int num6 = Div32Rem((int)num5, out remainder3);
                array4[index + (int)num5] = ((m_array[num6] >> remainder3) & 1) != 0;
            }
            return;
        }
        throw new ArgumentException(System.SR.Arg_BitArrayTypeUnsupported, "array");
    }

References System.Runtime.Intrinsics.X86.Sse2.And(), System.Runtime.Intrinsics.X86.Avx2.And(), System.Runtime.Intrinsics.Arm.AdvSimd.And(), System.SR.Arg_BitArrayTypeUnsupported, System.SR.Arg_RankMultiDimNotSupported, System.SR.Argument_InvalidOffLen, System.SR.ArgumentOutOfRange_NeedNonNegNum, System.array, System.Array.Copy(), System.Runtime.Intrinsics.Vector128< T >.Count, System.Runtime.Intrinsics.Vector128< T >.Create(), System.Runtime.Intrinsics.Vector256< T >.Create(), System.Runtime.Intrinsics.Vector128< T >.CreateScalarUnsafe(), System.destination, System.Collections.BitArray.Div32Rem(), System.Collections.BitArray.Div4Rem(), System.Collections.BitArray.GetByteArrayLengthFromBitLength(), System.index, System.BitConverter.IsLittleEndian, System.Runtime.Intrinsics.Arm.AdvSimd.IsSupported, System.Runtime.Intrinsics.X86.Avx2.IsSupported, System.Runtime.Intrinsics.X86.Ssse3.IsSupported, System.L, System.Collections.BitArray.m_array, System.Collections.BitArray.m_length, System.Runtime.Intrinsics.X86.Sse2.Min(), System.Runtime.Intrinsics.X86.Avx2.Min(), System.Runtime.Intrinsics.Arm.AdvSimd.Min(), System.Buffers.Binary.BinaryPrimitives.ReverseEndianness(), System.Runtime.Intrinsics.X86.Ssse3.Shuffle(), System.Runtime.Intrinsics.X86.Avx2.Shuffle(), System.source, System.Runtime.Intrinsics.Arm.AdvSimd.Store(), System.Runtime.Intrinsics.X86.Sse2.Store(), System.Runtime.Intrinsics.X86.Avx.Store(), System.value, System.Buffers.Binary.BinaryPrimitives.WriteInt32LittleEndian(), System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh(), and System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow().

Referenced by System.Security.Cryptography.EccKeyFormatHelper.GetSpecifiedECCurveCore(), and System.Security.Cryptography.EccKeyFormatHelper.GetSpecifiedECCurveCore().