1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
// ------------------------------------------------------------------------------
// Changes to this file must follow the http://aka.ms/api-review process.
// ------------------------------------------------------------------------------
namespace System
{
public readonly ref struct ReadOnlySpan<T>
{
public static ReadOnlySpan<T> Empty { get { throw null; } }
public ReadOnlySpan(T[] array) { throw null;}
public ReadOnlySpan(T[] array, int start, int length) { throw null;}
public unsafe ReadOnlySpan(void* pointer, int length) { throw null;}
public bool IsEmpty { get { throw null; } }
public T this[int index] { get { throw null; }}
public int Length { get { throw null; } }
public void CopyTo(Span<T> destination) { }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public static ReadOnlySpan<T> DangerousCreate(object obj, ref T objectData, int length) { throw null; }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public ref T DangerousGetPinnableReference() { throw null; }
#pragma warning disable 0809 //warning CS0809: Obsolete member 'Span<T>.Equals(object)' overrides non-obsolete member 'object.Equals(object)'
[System.ObsoleteAttribute("Equals() on ReadOnlySpan will always throw an exception. Use == instead.")]
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override bool Equals(object obj) { throw null; }
[System.ObsoleteAttribute("GetHashCode() on ReadOnlySpan will always throw an exception.")]
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override int GetHashCode() { throw null; }
#pragma warning restore 0809
public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right) { throw null; }
public static implicit operator ReadOnlySpan<T> (T[] array) { throw null; }
public static implicit operator ReadOnlySpan<T> (ArraySegment<T> arraySegment) { throw null; }
public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right) { throw null; }
public ReadOnlySpan<T> Slice(int start) { throw null; }
public ReadOnlySpan<T> Slice(int start, int length) { throw null; }
public T[] ToArray() { throw null; }
public bool TryCopyTo(Span<T> destination) { throw null; }
}
public readonly ref struct Span<T>
{
public static Span<T> Empty { get { throw null; } }
public Span(T[] array) { throw null;}
public Span(T[] array, int start, int length) { throw null;}
public unsafe Span(void* pointer, int length) { throw null;}
public bool IsEmpty { get { throw null; } }
public ref T this[int index] { get { throw null; } }
public int Length { get { throw null; } }
public void Clear() { }
public void Fill(T value) { }
public void CopyTo(Span<T> destination) { }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public static Span<T> DangerousCreate(object obj, ref T objectData, int length) { throw null; }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public ref T DangerousGetPinnableReference() { throw null; }
#pragma warning disable 0809 //warning CS0809: Obsolete member 'Span<T>.Equals(object)' overrides non-obsolete member 'object.Equals(object)'
[System.ObsoleteAttribute("Equals() on Span will always throw an exception. Use == instead.")]
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override bool Equals(object obj) { throw null; }
[System.ObsoleteAttribute("GetHashCode() on Span will always throw an exception.")]
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override int GetHashCode() { throw null; }
#pragma warning restore 0809
public static bool operator ==(Span<T> left, Span<T> right) { throw null; }
public static implicit operator Span<T> (T[] array) { throw null; }
public static implicit operator Span<T> (ArraySegment<T> arraySegment) { throw null; }
public static implicit operator ReadOnlySpan<T> (Span<T> span) { throw null; }
public static bool operator !=(Span<T> left, Span<T> right) { throw null; }
public Span<T> Slice(int start) { throw null; }
public Span<T> Slice(int start, int length) { throw null; }
public T[] ToArray() { throw null; }
public bool TryCopyTo(Span<T> destination) { throw null; }
}
public static class SpanExtensions
{
public static int IndexOf<T>(this Span<T> span, T value) where T:struct, IEquatable<T> { throw null; }
public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T> { throw null; }
public static int IndexOf(this Span<byte> span, byte value) { throw null; }
public static int IndexOf(this Span<byte> span, ReadOnlySpan<byte> value) { throw null; }
public static int IndexOfAny(this Span<byte> span, byte value0, byte value1) { throw null; }
public static int IndexOfAny(this Span<byte> span, byte value0, byte value1, byte value2) { throw null; }
public static int IndexOfAny(this Span<byte> span, ReadOnlySpan<byte> values) { throw null; }
public static bool SequenceEqual<T>(this Span<T> first, ReadOnlySpan<T> second) where T:struct, IEquatable<T> { throw null; }
public static bool SequenceEqual(this Span<byte> first, ReadOnlySpan<byte> second) { throw null; }
public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T> { throw null; }
public static bool StartsWith(this Span<byte> span, ReadOnlySpan<byte> value) { throw null; }
public static Span<byte> AsBytes<T>(this Span<T> source) where T : struct { throw null; }
public static Span<TTo> NonPortableCast<TFrom, TTo>(this Span<TFrom> source) where TFrom : struct where TTo : struct { throw null; }
public static ReadOnlySpan<char> AsReadOnlySpan(this string text) { throw null; }
public static Span<T> AsSpan<T>(this T[] array) { throw null; }
public static Span<T> AsSpan<T>(this ArraySegment<T> arraySegment) { throw null; }
public static ReadOnlySpan<T> AsReadOnlySpan<T>(this T[] array) { throw null; }
public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ArraySegment<T> arraySegment) { throw null; }
public static void CopyTo<T>(this T[] array, Span<T> destination) { throw null; }
public static int IndexOf<T>(this ReadOnlySpan<T> span, T value) where T : struct, IEquatable<T> { throw null; }
public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T> { throw null; }
public static int IndexOf(this ReadOnlySpan<byte> span, byte value) { throw null; }
public static int IndexOf(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> value) { throw null; }
public static int IndexOfAny(this ReadOnlySpan<byte> span, byte value0, byte value1) { throw null; }
public static int IndexOfAny(this ReadOnlySpan<byte> span, byte value0, byte value1, byte value2) { throw null; }
public static int IndexOfAny(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> values) { throw null; }
public static bool SequenceEqual<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : struct, IEquatable<T> { throw null; }
public static bool SequenceEqual(this ReadOnlySpan<byte> first, ReadOnlySpan<byte> second) { throw null; }
public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T> { throw null; }
public static bool StartsWith(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> value) { throw null; }
public static ReadOnlySpan<byte> AsBytes<T>(this ReadOnlySpan<T> source) where T : struct { throw null; }
public static ReadOnlySpan<TTo> NonPortableCast<TFrom, TTo>(this ReadOnlySpan<TFrom> source) where TFrom : struct where TTo : struct { throw null; }
}
public struct ReadOnlyMemory<T>
{
public static ReadOnlyMemory<T> Empty { get { throw null; } }
public ReadOnlyMemory(T[] array) { throw null;}
public ReadOnlyMemory(T[] array, int start, int length) { throw null;}
internal ReadOnlyMemory(Buffers.OwnedMemory<T> owner, int index, int length) { throw null;}
public bool IsEmpty { get { throw null; } }
public int Length { get { throw null; } }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override bool Equals(object obj) { throw null; }
public bool Equals(ReadOnlyMemory<T> other) { throw null; }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override int GetHashCode() { throw null; }
public static implicit operator ReadOnlyMemory<T>(T[] array) { throw null; }
public static implicit operator ReadOnlyMemory<T>(ArraySegment<T> arraySegment) { throw null; }
public ReadOnlyMemory<T> Slice(int start) { throw null; }
public ReadOnlyMemory<T> Slice(int start, int length) { throw null; }
public ReadOnlySpan<T> Span { get { throw null; } }
public unsafe Buffers.MemoryHandle Retain(bool pin = false) { throw null; }
public T[] ToArray() { throw null; }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool DangerousTryGetArray(out ArraySegment<T> arraySegment) { throw null; }
}
public struct Memory<T>
{
public static Memory<T> Empty { get { throw null; } }
public Memory(T[] array) { throw null;}
public Memory(T[] array, int start, int length) { throw null;}
internal Memory(Buffers.OwnedMemory<T> owner, int index, int length) { throw null;}
public bool IsEmpty { get { throw null; } }
public int Length { get { throw null; } }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override bool Equals(object obj) { throw null; }
public bool Equals(Memory<T> other) { throw null; }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public override int GetHashCode() { throw null; }
public static implicit operator Memory<T>(T[] array) { throw null; }
public static implicit operator Memory<T>(ArraySegment<T> arraySegment) { throw null; }
public static implicit operator ReadOnlyMemory<T>(Memory<T> memory) { throw null; }
public Memory<T> Slice(int start) { throw null; }
public Memory<T> Slice(int start, int length) { throw null; }
public Span<T> Span { get { throw null; } }
public unsafe Buffers.MemoryHandle Retain(bool pin = false) { throw null; }
public T[] ToArray() { throw null; }
public bool TryGetArray(out ArraySegment<T> arraySegment) { throw null; }
}
}
namespace System.Buffers
{
public unsafe struct MemoryHandle : IDisposable
{
public MemoryHandle(IRetainable owner, void* pinnedPointer = null, System.Runtime.InteropServices.GCHandle handle = default(System.Runtime.InteropServices.GCHandle)) { throw null; }
public void* PinnedPointer { get { throw null; } }
public void Dispose() { throw null; }
}
public interface IRetainable
{
bool Release();
void Retain();
}
public abstract class OwnedMemory<T> : IDisposable, IRetainable
{
public Memory<T> Memory { get { throw null; } }
public abstract bool IsDisposed { get; }
protected abstract bool IsRetained { get; }
public abstract int Length { get; }
public abstract Span<T> Span { get; }
public void Dispose() { throw null; }
protected abstract void Dispose(bool disposing);
public abstract MemoryHandle Pin();
public abstract bool Release();
public abstract void Retain();
protected internal abstract bool TryGetArray(out ArraySegment<T> arraySegment);
}
}
|
