ReadOnlySequenceFactory.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

#nullable enable

using System.Collections.Generic;
using System.Text;

namespace System.Buffers;

internal abstract class ReadOnlySequenceFactory
{
    public static ReadOnlySequenceFactory ArrayFactory { get; } = new ArrayTestSequenceFactory();
    public static ReadOnlySequenceFactory MemoryFactory { get; } = new MemoryTestSequenceFactory();
    public static ReadOnlySequenceFactory OwnedMemoryFactory { get; } = new OwnedMemoryTestSequenceFactory();
    public static ReadOnlySequenceFactory SingleSegmentFactory { get; } = new SingleSegmentTestSequenceFactory();
    public static ReadOnlySequenceFactory SegmentPerByteFactory { get; } = new BytePerSegmentTestSequenceFactory();

    public abstract ReadOnlySequence<byte> CreateOfSize(int size);
    public abstract ReadOnlySequence<byte> CreateWithContent(byte[] data);

    public ReadOnlySequence<byte> CreateWithContent(string data)
    {
        return CreateWithContent(Encoding.ASCII.GetBytes(data));
    }

    internal sealed class ArrayTestSequenceFactory : ReadOnlySequenceFactory
    {
        public override ReadOnlySequence<byte> CreateOfSize(int size)
        {
            return new ReadOnlySequence<byte>(new byte[size + 20], 10, size);
        }

        public override ReadOnlySequence<byte> CreateWithContent(byte[] data)
        {
            var startSegment = new byte[data.Length + 20];
            Array.Copy(data, 0, startSegment, 10, data.Length);
            return new ReadOnlySequence<byte>(startSegment, 10, data.Length);
        }
    }

    internal sealed class MemoryTestSequenceFactory : ReadOnlySequenceFactory
    {
        public override ReadOnlySequence<byte> CreateOfSize(int size)
        {
            return CreateWithContent(new byte[size]);
        }

        public override ReadOnlySequence<byte> CreateWithContent(byte[] data)
        {
            var startSegment = new byte[data.Length + 20];
            Array.Copy(data, 0, startSegment, 10, data.Length);
            return new ReadOnlySequence<byte>(new Memory<byte>(startSegment, 10, data.Length));
        }
    }

    internal sealed class OwnedMemoryTestSequenceFactory : ReadOnlySequenceFactory
    {
        public override ReadOnlySequence<byte> CreateOfSize(int size)
        {
            return CreateWithContent(new byte[size]);
        }

        public override ReadOnlySequence<byte> CreateWithContent(byte[] data)
        {
            var startSegment = new byte[data.Length + 20];
            Array.Copy(data, 0, startSegment, 10, data.Length);
            return new ReadOnlySequence<byte>(new CustomMemoryForTest<byte>(startSegment, 10, data.Length).Memory);
        }
    }

    internal sealed class SingleSegmentTestSequenceFactory : ReadOnlySequenceFactory
    {
        public override ReadOnlySequence<byte> CreateOfSize(int size)
        {
            return CreateWithContent(new byte[size]);
        }

        public override ReadOnlySequence<byte> CreateWithContent(byte[] data)
        {
            return CreateSegments(data);
        }
    }

    internal sealed class BytePerSegmentTestSequenceFactory : ReadOnlySequenceFactory
    {
        public override ReadOnlySequence<byte> CreateOfSize(int size)
        {
            return CreateWithContent(new byte[size]);
        }

        public override ReadOnlySequence<byte> CreateWithContent(byte[] data)
        {
            var segments = new List<byte[]>((data.Length * 2) + 1);

            segments.Add(Array.Empty<byte>());
            foreach (var b in data)
            {
                segments.Add(new[] { b });
                segments.Add(Array.Empty<byte>());
            }

            return CreateSegments(segments.ToArray());
        }
    }

    public static ReadOnlySequence<byte> CreateSegments(params byte[][] inputs)
    {
        if (inputs == null || inputs.Length == 0)
        {
            throw new InvalidOperationException();
        }

        int i = 0;

        BufferSegment? last = null;
        BufferSegment? first = null;

        do
        {
            byte[] s = inputs[i];
            int length = s.Length;
            int dataOffset = length;
            var chars = new byte[length * 2];

            for (int j = 0; j < length; j++)
            {
                chars[dataOffset + j] = s[j];
            }

            // Create a segment that has offset relative to the OwnedMemory and OwnedMemory itself has offset relative to array
            var memory = new Memory<byte>(chars).Slice(length, length);

            if (first == null)
            {
                first = new BufferSegment(memory);
                last = first;
            }
            else
            {
                last = last!.Append(memory);
            }
            i++;
        } while (i < inputs.Length);

        return new ReadOnlySequence<byte>(first, 0, last, last.Memory.Length);
    }
}