Api diff between 2.0 and 2.1

release-notes/2.1/api-diff/2.0-vs-2.1_System.Buffers.md

@@ -0,0 +1,118 @@
+# System.Buffers
+
+``` diff
+ namespace System.Buffers {
++    public static class BuffersExtensions {
++        public static void CopyTo<T>(this ref ReadOnlySequence<T> source, Span<T> destination);
++        public static Nullable<SequencePosition> PositionOf<T>(this ref ReadOnlySequence<T> source, T value) where T : IEquatable<T>;
++        public static T[] ToArray<T>(this ref ReadOnlySequence<T> sequence);
++        public static void Write<T>(this IBufferWriter<T> writer, ReadOnlySpan<T> value);
++    }
++    public interface IBufferWriter<T> {
++        void Advance(int count);
++        Memory<T> GetMemory(int sizeHint=0);
++        Span<T> GetSpan(int sizeHint=0);
++    }
++    public interface IMemoryOwner<T> : IDisposable {
++        Memory<T> Memory { get; }
++    }
++    public interface IPinnable {
++        MemoryHandle Pin(int elementIndex);
++        void Unpin();
++    }
++    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
++    public struct MemoryHandle : IDisposable {
++        public unsafe MemoryHandle(void* pointer, GCHandle handle=default(GCHandle), IPinnable pinnable=null);
++        public unsafe void* Pointer { get; }
++        public void Dispose();
++    }
++    public abstract class MemoryManager<T> : IDisposable, IMemoryOwner<T>, IPinnable {
++        protected MemoryManager();
++        public virtual Memory<T> Memory { get; }
++        protected Memory<T> CreateMemory(int length);
++        protected Memory<T> CreateMemory(int start, int length);
++        protected abstract void Dispose(bool disposing);
++        public abstract Span<T> GetSpan();
++        public abstract MemoryHandle Pin(int elementIndex=0);
++        void System.IDisposable.Dispose();
++        protected internal virtual bool TryGetArray(out ArraySegment<T> segment);
++        public abstract void Unpin();
++    }
++    public abstract class MemoryPool<T> : IDisposable {
++        protected MemoryPool();
++        public abstract int MaxBufferSize { get; }
++        public static MemoryPool<T> Shared { get; }
++        public void Dispose();
++        protected abstract void Dispose(bool disposing);
++        public abstract IMemoryOwner<T> Rent(int minBufferSize=-1);
++    }
++    public enum OperationStatus {
++        DestinationTooSmall = 1,
++        Done = 0,
++        InvalidData = 3,
++        NeedMoreData = 2,
++    }
++    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
++    public struct ReadOnlySequence<T> {
++        public static readonly ReadOnlySequence<T> Empty;
++        public ReadOnlySequence(ReadOnlySequenceSegment<T> startSegment, int startIndex, ReadOnlySequenceSegment<T> endSegment, int endIndex);
++        public ReadOnlySequence(ReadOnlyMemory<T> memory);
++        public ReadOnlySequence(T[] array);
++        public ReadOnlySequence(T[] array, int start, int length);
++        public SequencePosition End { get; }
++        public ReadOnlyMemory<T> First { get; }
++        public bool IsEmpty { get; }
++        public bool IsSingleSegment { get; }
++        public long Length { get; }
++        public SequencePosition Start { get; }
++        public ReadOnlySequence<T>.Enumerator GetEnumerator();
++        public SequencePosition GetPosition(long offset);
++        public SequencePosition GetPosition(long offset, SequencePosition origin);
++        public ReadOnlySequence<T> Slice(int start, int length);
++        public ReadOnlySequence<T> Slice(int start, SequencePosition end);
++        public ReadOnlySequence<T> Slice(long start);
++        public ReadOnlySequence<T> Slice(long start, long length);
++        public ReadOnlySequence<T> Slice(long start, SequencePosition end);
++        public ReadOnlySequence<T> Slice(SequencePosition start);
++        public ReadOnlySequence<T> Slice(SequencePosition start, int length);
++        public ReadOnlySequence<T> Slice(SequencePosition start, long length);
++        public ReadOnlySequence<T> Slice(SequencePosition start, SequencePosition end);
++        public override string ToString();
++        public bool TryGet(ref SequencePosition position, out ReadOnlyMemory<T> memory, bool advance=true);
++        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
++        public struct Enumerator {
++            public Enumerator(ref ReadOnlySequence<T> sequence);
++            public ReadOnlyMemory<T> Current { get; }
++            public bool MoveNext();
++        }
++    }
++    public abstract class ReadOnlySequenceSegment<T> {
++        protected ReadOnlySequenceSegment();
++        public ReadOnlyMemory<T> Memory { get; protected set; }
++        public ReadOnlySequenceSegment<T> Next { get; protected set; }
++        public long RunningIndex { get; protected set; }
++    }
++    public delegate void ReadOnlySpanAction<T, in TArg>(ReadOnlySpan<T> span, TArg arg);
++    public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg);
++    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
++    public struct StandardFormat : IEquatable<StandardFormat> {
++        public const byte MaxPrecision = (byte)99;
++        public const byte NoPrecision = (byte)255;
++        public StandardFormat(char symbol, byte precision=(byte)255);
++        public bool HasPrecision { get; }
++        public bool IsDefault { get; }
++        public byte Precision { get; }
++        public char Symbol { get; }
++        public bool Equals(StandardFormat other);
++        public override bool Equals(object obj);
++        public override int GetHashCode();
++        public static bool operator ==(StandardFormat left, StandardFormat right);
++        public static implicit operator StandardFormat (char symbol);
++        public static bool operator !=(StandardFormat left, StandardFormat right);
++        public static StandardFormat Parse(ReadOnlySpan<char> format);
++        public static StandardFormat Parse(string format);
++        public override string ToString();
++    }
+ }
+```
+