mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 6.6.0.103

Browse Source 
Former-commit-id: ed8637df0061cb6f128ae1d26d26db7734e0fa0d
This commit is contained in:
Xamarin Public Jenkins (auto-signing) 2019-10-01 09:12:40 +00:00
parent 53ae335b9c
commit 9b1ef54dc9
78 changed files with 2577 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure.REMOVED.git-id
View File

@ -1 +1 @@
6bd4558f248b14a2a82737af0c9b1d2b0b2944d3
60a79a7b89a82334772050675ba7da0cc4f910d1

2
configure.ac.REMOVED.git-id
View File

@ -1 +1 @@
839127d83c8dfc3cbe1eabd09588a5b57eae1fac
ed50e44c7b9748cf25b5006cd5407e8134531cab

2
external/api-snapshot/profiles/monodroid/Facades/netstandard.cs.REMOVED.git-id vendored
View File

@ -1 +1 @@
faec721a749e501975809f748630ed297fd55e50
9072ff67e7c4c540bc2e40267fc5f946b65bf9a1

107
external/api-snapshot/profiles/monodroid/System.Data.DataSetExtensions.cs vendored Normal file
View File

@ -0,0 +1,107 @@
// 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.
[assembly:System.Reflection.AssemblyVersionAttribute("2.0.5.0")]
[assembly:System.CLSCompliantAttribute(true)]
[assembly:System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly:System.Reflection.AssemblyCompanyAttribute("Mono development team")]
[assembly:System.Reflection.AssemblyCopyrightAttribute("(c) Various Mono authors")]
[assembly:System.Reflection.AssemblyDefaultAliasAttribute("System.Data.DataSetExtensions.dll")]
[assembly:System.Reflection.AssemblyDescriptionAttribute("System.Data.DataSetExtensions.dll")]
[assembly:System.Reflection.AssemblyFileVersionAttribute("4.0.50524.0")]
[assembly:System.Reflection.AssemblyInformationalVersionAttribute("4.0.50524.0")]
[assembly:System.Reflection.AssemblyProductAttribute("Mono Common Language Infrastructure")]
[assembly:System.Reflection.AssemblyTitleAttribute("System.Data.DataSetExtensions.dll")]
[assembly:System.Resources.NeutralResourcesLanguageAttribute("en-US")]
[assembly:System.Resources.SatelliteContractVersionAttribute("2.0.5.0")]
[assembly:System.Runtime.CompilerServices.CompilationRelaxationsAttribute(System.Runtime.CompilerServices.CompilationRelaxations.NoStringInterning)]
[assembly:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows=true)]
[assembly:System.Runtime.InteropServices.ComCompatibleVersionAttribute(1, 0, 3300, 0)]
[assembly:System.Runtime.InteropServices.ComVisibleAttribute(false)]
[assembly:System.Security.AllowPartiallyTrustedCallersAttribute]
[assembly:System.Security.SecurityCriticalAttribute]
namespace System.Data
{
public static partial class DataRowComparer
{
public static System.Data.DataRowComparer<System.Data.DataRow> Default { get { throw null; } }
}
public sealed partial class DataRowComparer<TRow> : System.Collections.Generic.IEqualityComparer<TRow> where TRow : System.Data.DataRow
{
internal DataRowComparer() { }
public static System.Data.DataRowComparer<TRow> Default { get { throw null; } }
public bool Equals(TRow leftRow, TRow rightRow) { throw null; }
public int GetHashCode(TRow row) { throw null; }
}
public static partial class DataRowExtensions
{
public static T Field<T>(this System.Data.DataRow row, System.Data.DataColumn column) { throw null; }
public static T Field<T>(this System.Data.DataRow row, System.Data.DataColumn column, System.Data.DataRowVersion version) { throw null; }
public static T Field<T>(this System.Data.DataRow row, int columnIndex) { throw null; }
public static T Field<T>(this System.Data.DataRow row, int columnIndex, System.Data.DataRowVersion version) { throw null; }
public static T Field<T>(this System.Data.DataRow row, string columnName) { throw null; }
public static T Field<T>(this System.Data.DataRow row, string columnName, System.Data.DataRowVersion version) { throw null; }
public static void SetField<T>(this System.Data.DataRow row, System.Data.DataColumn column, T value) { }
public static void SetField<T>(this System.Data.DataRow row, int columnIndex, T value) { }
public static void SetField<T>(this System.Data.DataRow row, string columnName, T value) { }
}
public static partial class DataTableExtensions
{
public static System.Data.DataView AsDataView(this System.Data.DataTable table) { throw null; }
public static System.Data.DataView AsDataView<T>(this System.Data.EnumerableRowCollection<T> source) where T : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<System.Data.DataRow> AsEnumerable(this System.Data.DataTable source) { throw null; }
public static System.Data.DataTable CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source) where T : System.Data.DataRow { throw null; }
public static void CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source, System.Data.DataTable table, System.Data.LoadOption options) where T : System.Data.DataRow { }
public static void CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source, System.Data.DataTable table, System.Data.LoadOption options, System.Data.FillErrorEventHandler errorHandler) where T : System.Data.DataRow { }
}
public abstract partial class EnumerableRowCollection : System.Collections.IEnumerable
{
internal EnumerableRowCollection() { }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
}
public static partial class EnumerableRowCollectionExtensions
{
public static System.Data.EnumerableRowCollection<TResult> Cast<TResult>(this System.Data.EnumerableRowCollection source) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.EnumerableRowCollection<S> Select<TRow, S>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, S> selector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.EnumerableRowCollection<TRow> Where<TRow>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, bool> predicate) { throw null; }
}
public partial class EnumerableRowCollection<TRow> : System.Data.EnumerableRowCollection, System.Collections.Generic.IEnumerable<TRow>, System.Collections.IEnumerable
{
internal EnumerableRowCollection() { }
public System.Collections.Generic.IEnumerator<TRow> GetEnumerator() { throw null; }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
}
public sealed partial class OrderedEnumerableRowCollection<TRow> : System.Data.EnumerableRowCollection<TRow>
{
internal OrderedEnumerableRowCollection() { }
}
public static partial class TypedTableBaseExtensions
{
public static System.Data.EnumerableRowCollection<TRow> AsEnumerable<TRow>(this System.Data.TypedTableBase<TRow> source) where TRow : System.Data.DataRow { throw null; }
public static TRow ElementAtOrDefault<TRow>(this System.Data.TypedTableBase<TRow> source, int index) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) where TRow : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<S> Select<TRow, S>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, S> selector) where TRow : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<TRow> Where<TRow>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, bool> predicate) where TRow : System.Data.DataRow { throw null; }
}
[System.SerializableAttribute]
public abstract partial class TypedTableBase<T> : System.Data.DataTable, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable where T : System.Data.DataRow
{
protected TypedTableBase() { }
protected TypedTableBase(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public System.Data.EnumerableRowCollection<TResult> Cast<TResult>() { throw null; }
public System.Collections.Generic.IEnumerator<T> GetEnumerator() { throw null; }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
}
}

2
external/api-snapshot/profiles/monodroid/mscorlib.cs.REMOVED.git-id vendored
View File

@ -1 +1 @@
fd51a18a3a062b480d134e7d3ad089cb7c6db94b
4eab3daf447a9db125e2b7d24282b35b14aa7f64

2
external/api-snapshot/profiles/monotouch/Facades/netstandard.cs.REMOVED.git-id vendored
View File

@ -1 +1 @@
faec721a749e501975809f748630ed297fd55e50
9072ff67e7c4c540bc2e40267fc5f946b65bf9a1

107
external/api-snapshot/profiles/monotouch/System.Data.DataSetExtensions.cs vendored Normal file
View File

@ -0,0 +1,107 @@
// 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.
[assembly:System.Reflection.AssemblyVersionAttribute("2.0.5.0")]
[assembly:System.CLSCompliantAttribute(true)]
[assembly:System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly:System.Reflection.AssemblyCompanyAttribute("Mono development team")]
[assembly:System.Reflection.AssemblyCopyrightAttribute("(c) Various Mono authors")]
[assembly:System.Reflection.AssemblyDefaultAliasAttribute("System.Data.DataSetExtensions.dll")]
[assembly:System.Reflection.AssemblyDescriptionAttribute("System.Data.DataSetExtensions.dll")]
[assembly:System.Reflection.AssemblyFileVersionAttribute("4.0.50524.0")]
[assembly:System.Reflection.AssemblyInformationalVersionAttribute("4.0.50524.0")]
[assembly:System.Reflection.AssemblyProductAttribute("Mono Common Language Infrastructure")]
[assembly:System.Reflection.AssemblyTitleAttribute("System.Data.DataSetExtensions.dll")]
[assembly:System.Resources.NeutralResourcesLanguageAttribute("en-US")]
[assembly:System.Resources.SatelliteContractVersionAttribute("2.0.5.0")]
[assembly:System.Runtime.CompilerServices.CompilationRelaxationsAttribute(System.Runtime.CompilerServices.CompilationRelaxations.NoStringInterning)]
[assembly:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows=true)]
[assembly:System.Runtime.InteropServices.ComCompatibleVersionAttribute(1, 0, 3300, 0)]
[assembly:System.Runtime.InteropServices.ComVisibleAttribute(false)]
[assembly:System.Security.AllowPartiallyTrustedCallersAttribute]
[assembly:System.Security.SecurityCriticalAttribute]
namespace System.Data
{
public static partial class DataRowComparer
{
public static System.Data.DataRowComparer<System.Data.DataRow> Default { get { throw null; } }
}
public sealed partial class DataRowComparer<TRow> : System.Collections.Generic.IEqualityComparer<TRow> where TRow : System.Data.DataRow
{
internal DataRowComparer() { }
public static System.Data.DataRowComparer<TRow> Default { get { throw null; } }
public bool Equals(TRow leftRow, TRow rightRow) { throw null; }
public int GetHashCode(TRow row) { throw null; }
}
public static partial class DataRowExtensions
{
public static T Field<T>(this System.Data.DataRow row, System.Data.DataColumn column) { throw null; }
public static T Field<T>(this System.Data.DataRow row, System.Data.DataColumn column, System.Data.DataRowVersion version) { throw null; }
public static T Field<T>(this System.Data.DataRow row, int columnIndex) { throw null; }
public static T Field<T>(this System.Data.DataRow row, int columnIndex, System.Data.DataRowVersion version) { throw null; }
public static T Field<T>(this System.Data.DataRow row, string columnName) { throw null; }
public static T Field<T>(this System.Data.DataRow row, string columnName, System.Data.DataRowVersion version) { throw null; }
public static void SetField<T>(this System.Data.DataRow row, System.Data.DataColumn column, T value) { }
public static void SetField<T>(this System.Data.DataRow row, int columnIndex, T value) { }
public static void SetField<T>(this System.Data.DataRow row, string columnName, T value) { }
}
public static partial class DataTableExtensions
{
public static System.Data.DataView AsDataView(this System.Data.DataTable table) { throw null; }
public static System.Data.DataView AsDataView<T>(this System.Data.EnumerableRowCollection<T> source) where T : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<System.Data.DataRow> AsEnumerable(this System.Data.DataTable source) { throw null; }
public static System.Data.DataTable CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source) where T : System.Data.DataRow { throw null; }
public static void CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source, System.Data.DataTable table, System.Data.LoadOption options) where T : System.Data.DataRow { }
public static void CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source, System.Data.DataTable table, System.Data.LoadOption options, System.Data.FillErrorEventHandler errorHandler) where T : System.Data.DataRow { }
}
public abstract partial class EnumerableRowCollection : System.Collections.IEnumerable
{
internal EnumerableRowCollection() { }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
}
public static partial class EnumerableRowCollectionExtensions
{
public static System.Data.EnumerableRowCollection<TResult> Cast<TResult>(this System.Data.EnumerableRowCollection source) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.EnumerableRowCollection<S> Select<TRow, S>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, S> selector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector) { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this System.Data.OrderedEnumerableRowCollection<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { throw null; }
public static System.Data.EnumerableRowCollection<TRow> Where<TRow>(this System.Data.EnumerableRowCollection<TRow> source, System.Func<TRow, bool> predicate) { throw null; }
}
public partial class EnumerableRowCollection<TRow> : System.Data.EnumerableRowCollection, System.Collections.Generic.IEnumerable<TRow>, System.Collections.IEnumerable
{
internal EnumerableRowCollection() { }
public System.Collections.Generic.IEnumerator<TRow> GetEnumerator() { throw null; }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
}
public sealed partial class OrderedEnumerableRowCollection<TRow> : System.Data.EnumerableRowCollection<TRow>
{
internal OrderedEnumerableRowCollection() { }
}
public static partial class TypedTableBaseExtensions
{
public static System.Data.EnumerableRowCollection<TRow> AsEnumerable<TRow>(this System.Data.TypedTableBase<TRow> source) where TRow : System.Data.DataRow { throw null; }
public static TRow ElementAtOrDefault<TRow>(this System.Data.TypedTableBase<TRow> source, int index) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector) where TRow : System.Data.DataRow { throw null; }
public static System.Data.OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) where TRow : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<S> Select<TRow, S>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, S> selector) where TRow : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<TRow> Where<TRow>(this System.Data.TypedTableBase<TRow> source, System.Func<TRow, bool> predicate) where TRow : System.Data.DataRow { throw null; }
}
[System.SerializableAttribute]
public abstract partial class TypedTableBase<T> : System.Data.DataTable, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable where T : System.Data.DataRow
{
protected TypedTableBase() { }
protected TypedTableBase(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public System.Data.EnumerableRowCollection<TResult> Cast<TResult>() { throw null; }
public System.Collections.Generic.IEnumerator<T> GetEnumerator() { throw null; }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
}
}

2
external/api-snapshot/profiles/monotouch/mscorlib.cs.REMOVED.git-id vendored
View File

@ -1 +1 @@
4048a50560e4e0704415a46f55f1b706095331b4
90d02a101ed04da6a18a169ddf1ec2799c16fcdf

2
external/api-snapshot/profiles/net_4_x/Facades/netstandard.cs.REMOVED.git-id vendored
View File

@ -1 +1 @@
faec721a749e501975809f748630ed297fd55e50
9072ff67e7c4c540bc2e40267fc5f946b65bf9a1

2
external/api-snapshot/profiles/net_4_x/System.Data.DataSetExtensions.cs vendored
View File

@ -48,6 +48,8 @@ namespace System.Data
}
public static partial class DataTableExtensions
{
public static System.Data.DataView AsDataView(this System.Data.DataTable table) { throw null; }
public static System.Data.DataView AsDataView<T>(this System.Data.EnumerableRowCollection<T> source) where T : System.Data.DataRow { throw null; }
public static System.Data.EnumerableRowCollection<System.Data.DataRow> AsEnumerable(this System.Data.DataTable source) { throw null; }
public static System.Data.DataTable CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source) where T : System.Data.DataRow { throw null; }
public static void CopyToDataTable<T>(this System.Collections.Generic.IEnumerable<T> source, System.Data.DataTable table, System.Data.LoadOption options) where T : System.Data.DataRow { }

2
external/api-snapshot/profiles/net_4_x/mscorlib.cs.REMOVED.git-id vendored
View File

@ -1 +1 @@
3d6057ed36a94c8b67e4b28f2a871ff0127ea381
03f0d6f3e5645ad55d73b26135212076a5119877

14
external/corefx/src/Common/src/CoreLib/System/Math.cs vendored
View File

@ -132,6 +132,20 @@ namespace System
return div;
}
internal static uint DivRem(uint a, uint b, out uint result)
{
uint div = a / b;
result = a - (div * b);
return div;
}
internal static ulong DivRem(ulong a, ulong b, out ulong result)
{
ulong div = a / b;
result = a - (div * b);
return div;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static decimal Ceiling(decimal d)
{

22
external/corefx/src/System.Data.DataSetExtensions/src/System/Data/DataTableExtensions.cs vendored
View File

@ -218,5 +218,27 @@ namespace System.Data
Debug.Assert(null != table, "null DataTable");
return table;
}
/// <summary>
/// Creates a LinkDataView of DataRow over the input table.
/// </summary>
/// <param name="table">DataTable that the view is over.</param>
/// <returns>An instance of LinkDataView.</returns>
public static DataView AsDataView(this DataTable table)
{
throw new PlatformNotSupportedException ();
}
/// <summary>
/// Creates a LinqDataView from EnumerableDataTable
/// </summary>
/// <typeparam name="T">Type of the row in the table. Must inherit from DataRow</typeparam>
/// <param name="source">The enumerable-datatable over which view must be created.</param>
/// <returns>Generated LinkDataView of type T</returns>
public static DataView AsDataView<T>(this EnumerableRowCollection<T> source) where T : DataRow
{
throw new PlatformNotSupportedException ();
}
}
}

2
external/corefx/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.OSX.cs vendored
View File

@ -280,8 +280,6 @@ namespace System.IO
finally
{
StaticWatcherRunLoopManager.UnscheduleFromRunLoop(_eventStream);
_eventStream.Close();
_eventStream = null;
}
}
}

58
external/corefx/src/System.Linq.Queryable/src/System/Linq/EnumerableRewriter.cs vendored
View File

@ -8,7 +8,6 @@ using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace System.Linq
{
@ -213,63 +212,6 @@ namespace System.Linq
private static ILookup<string, MethodInfo> s_seqMethods;
[PreserveDependency ("Aggregate`1", "System.Linq.Enumerable")]
[PreserveDependency ("Aggregate`2", "System.Linq.Enumerable")]
[PreserveDependency ("Aggregate`3", "System.Linq.Enumerable")]
[PreserveDependency ("All`1", "System.Linq.Enumerable")]
[PreserveDependency ("Any`1", "System.Linq.Enumerable")]
[PreserveDependency ("Append`1", "System.Linq.Enumerable")]
[PreserveDependency ("Average", "System.Linq.Enumerable")]
[PreserveDependency ("Average`1", "System.Linq.Enumerable")]
[PreserveDependency ("Cast`1", "System.Linq.Enumerable")]
[PreserveDependency ("Concat`1", "System.Linq.Enumerable")]
[PreserveDependency ("Contains`1", "System.Linq.Enumerable")]
[PreserveDependency ("Count`1", "System.Linq.Enumerable")]
[PreserveDependency ("DefaultIfEmpty`1", "System.Linq.Enumerable")]
[PreserveDependency ("Distinct`1", "System.Linq.Enumerable")]
[PreserveDependency ("ElementAt`1", "System.Linq.Enumerable")]
[PreserveDependency ("ElementAtOrDefault`1", "System.Linq.Enumerable")]
[PreserveDependency ("Except`1", "System.Linq.Enumerable")]
[PreserveDependency ("First`1", "System.Linq.Enumerable")]
[PreserveDependency ("FirstOrDefault`1", "System.Linq.Enumerable")]
[PreserveDependency ("GroupBy`2", "System.Linq.Enumerable")]
[PreserveDependency ("GroupBy`3", "System.Linq.Enumerable")]
[PreserveDependency ("GroupBy`4", "System.Linq.Enumerable")]
[PreserveDependency ("GroupJoin`4", "System.Linq.Enumerable")]
[PreserveDependency ("Intersect`1", "System.Linq.Enumerable")]
[PreserveDependency ("Join`4", "System.Linq.Enumerable")]
[PreserveDependency ("Last`1", "System.Linq.Enumerable")]
[PreserveDependency ("LastOrDefault`1", "System.Linq.Enumerable")]
[PreserveDependency ("LongCount`1", "System.Linq.Enumerable")]
[PreserveDependency ("Max`1", "System.Linq.Enumerable")]
[PreserveDependency ("Max`2", "System.Linq.Enumerable")]
[PreserveDependency ("Min`1", "System.Linq.Enumerable")]
[PreserveDependency ("Min`2", "System.Linq.Enumerable")]
[PreserveDependency ("OfType`1", "System.Linq.Enumerable")]
[PreserveDependency ("OrderBy`2", "System.Linq.Enumerable")]
[PreserveDependency ("OrderByDescending`2", "System.Linq.Enumerable")]
[PreserveDependency ("Prepend`1", "System.Linq.Enumerable")]
[PreserveDependency ("Reverse`1", "System.Linq.Enumerable")]
[PreserveDependency ("Select`2", "System.Linq.Enumerable")]
[PreserveDependency ("SelectMany`2", "System.Linq.Enumerable")]
[PreserveDependency ("SelectMany`3", "System.Linq.Enumerable")]
[PreserveDependency ("SequenceEqual`1", "System.Linq.Enumerable")]
[PreserveDependency ("Single`1", "System.Linq.Enumerable")]
[PreserveDependency ("SingleOrDefault`1", "System.Linq.Enumerable")]
[PreserveDependency ("Skip`1", "System.Linq.Enumerable")]
[PreserveDependency ("SkipLast`1", "System.Linq.Enumerable")]
[PreserveDependency ("SkipWhile`1", "System.Linq.Enumerable")]
[PreserveDependency ("Sum", "System.Linq.Enumerable")]
[PreserveDependency ("Sum`1", "System.Linq.Enumerable")]
[PreserveDependency ("Take`1", "System.Linq.Enumerable")]
[PreserveDependency ("TakeLast`1", "System.Linq.Enumerable")]
[PreserveDependency ("TakeWhile`1", "System.Linq.Enumerable")]
[PreserveDependency ("ThenBy`2", "System.Linq.Enumerable")]
[PreserveDependency ("ThenByDescending`2", "System.Linq.Enumerable")]
[PreserveDependency ("Union`1", "System.Linq.Enumerable")]
[PreserveDependency ("Where`1", "System.Linq.Enumerable")]
[PreserveDependency ("Zip`3", "System.Linq.Enumerable")]
private static MethodInfo FindEnumerableMethod(string name, ReadOnlyCollection<Expression> args, params Type[] typeArgs)
{
if (s_seqMethods == null)

209
external/corefx/src/System.Memory/src/System/Buffers/ReadOnlySequence.cs vendored
View File

@ -3,11 +3,10 @@
// See the LICENSE file in the project root for more information.
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
#if !FEATURE_PORTABLE_SPAN
using Internal.Runtime.CompilerServices;
#endif // FEATURE_PORTABLE_SPAN
namespace System.Buffers
{
@ -18,17 +17,16 @@ namespace System.Buffers
[DebuggerDisplay("{ToString(),raw}")]
public readonly partial struct ReadOnlySequence<T>
{
private readonly SequencePosition _sequenceStart;
private readonly SequencePosition _sequenceEnd;
// The data is essentially two SequencePositions, however the Start and End SequencePositions are deconstructed to improve packing.
private readonly object _startObject;
private readonly object _endObject;
private readonly int _startInteger;
private readonly int _endInteger;
/// <summary>
/// Returns empty <see cref="ReadOnlySequence{T}"/>
/// </summary>
#if FEATURE_PORTABLE_SPAN
public static readonly ReadOnlySequence<T> Empty = new ReadOnlySequence<T>(SpanHelpers.PerTypeValues<T>.EmptyArray);
#else
public static readonly ReadOnlySequence<T> Empty = new ReadOnlySequence<T>(Array.Empty<T>());
#endif // FEATURE_PORTABLE_SPAN
/// <summary>
/// Length of the <see cref="ReadOnlySequence{T}"/>.
@ -46,7 +44,7 @@ namespace System.Buffers
public bool IsSingleSegment
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _sequenceStart.GetObject() == _sequenceEnd.GetObject();
get => _startObject == _endObject;
}
/// <summary>
@ -54,15 +52,28 @@ namespace System.Buffers
/// </summary>
public ReadOnlyMemory<T> First => GetFirstBuffer();
/// <summary>
/// Gets <see cref="ReadOnlySpan{T}"/> from the first segment.
/// </summary>
public ReadOnlySpan<T> FirstSpan => GetFirstSpan();
/// <summary>
/// A position to the start of the <see cref="ReadOnlySequence{T}"/>.
/// </summary>
public SequencePosition Start => _sequenceStart;
public SequencePosition Start
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => new SequencePosition(_startObject, _startInteger);
}
/// <summary>
/// A position to the end of the <see cref="ReadOnlySequence{T}"/>
/// </summary>
public SequencePosition End => _sequenceEnd;
public SequencePosition End
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => new SequencePosition(_endObject, _endInteger);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private ReadOnlySequence(object startSegment, int startIndexAndFlags, object endSegment, int endIndexAndFlags)
@ -73,8 +84,10 @@ namespace System.Buffers
Debug.Assert((startSegment != null && endSegment != null) ||
(startSegment == null && endSegment == null && startIndexAndFlags == 0 && endIndexAndFlags == 0));
_sequenceStart = new SequencePosition(startSegment, startIndexAndFlags);
_sequenceEnd = new SequencePosition(endSegment, endIndexAndFlags);
_startObject = startSegment;
_endObject = endSegment;
_startInteger = startIndexAndFlags;
_endInteger = endIndexAndFlags;
}
/// <summary>
@ -91,24 +104,28 @@ namespace System.Buffers
(startSegment == endSegment && endIndex < startIndex))
ThrowHelper.ThrowArgumentValidationException(startSegment, startIndex, endSegment);
_sequenceStart = new SequencePosition(startSegment, ReadOnlySequence.SegmentToSequenceStart(startIndex));
_sequenceEnd = new SequencePosition(endSegment, ReadOnlySequence.SegmentToSequenceEnd(endIndex));
_startObject = startSegment;
_endObject = endSegment;
_startInteger = ReadOnlySequence.SegmentToSequenceStart(startIndex);
_endInteger = ReadOnlySequence.SegmentToSequenceEnd(endIndex);
}
/// <summary>
/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="T:T[]"/>.
/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the array.
/// </summary>
public ReadOnlySequence(T[] array)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(0));
_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(array.Length));
_startObject = array;
_endObject = array;
_startInteger = ReadOnlySequence.ArrayToSequenceStart(0);
_endInteger = ReadOnlySequence.ArrayToSequenceEnd(array.Length);
}
/// <summary>
/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="T:T[]"/>, start and index.
/// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the array, start, and index.
/// </summary>
public ReadOnlySequence(T[] array, int start, int length)
{
@ -117,8 +134,10 @@ namespace System.Buffers
(uint)length > (uint)(array.Length - start))
ThrowHelper.ThrowArgumentValidationException(array, start);
_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(start));
_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(start + length));
_startObject = array;
_endObject = array;
_startInteger = ReadOnlySequence.ArrayToSequenceStart(start);
_endInteger = ReadOnlySequence.ArrayToSequenceEnd(start + length);
}
/// <summary>
@ -127,40 +146,51 @@ namespace System.Buffers
/// </summary>
public ReadOnlySequence(ReadOnlyMemory<T> memory)
{
#pragma warning disable CS8631 // TODO-NULLABLE: ILLink rewriter removing some necessary metadata (https://github.com/dotnet/corefx/pull/38983#issuecomment-506757237)
if (MemoryMarshal.TryGetMemoryManager(memory, out MemoryManager<T> manager, out int index, out int length))
#pragma warning restore CS8631
{
_sequenceStart = new SequencePosition(manager, ReadOnlySequence.MemoryManagerToSequenceStart(index));
_sequenceEnd = new SequencePosition(manager, ReadOnlySequence.MemoryManagerToSequenceEnd(length));
_startObject = manager;
_endObject = manager;
_startInteger = ReadOnlySequence.MemoryManagerToSequenceStart(index);
_endInteger = ReadOnlySequence.MemoryManagerToSequenceEnd(length);
}
else if (MemoryMarshal.TryGetArray(memory, out ArraySegment<T> segment))
{
T[] array = segment.Array;
int start = segment.Offset;
_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(start));
_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(start + segment.Count));
_startObject = array;
_endObject = array;
_startInteger = ReadOnlySequence.ArrayToSequenceStart(start);
_endInteger = ReadOnlySequence.ArrayToSequenceEnd(start + segment.Count);
}
else if (typeof(T) == typeof(char))
{
if (!MemoryMarshal.TryGetString(((ReadOnlyMemory<char>)(object)memory), out string text, out int start, out length))
if (!MemoryMarshal.TryGetString((ReadOnlyMemory<char>)(object)memory, out string text, out int start, out length))
ThrowHelper.ThrowInvalidOperationException();
_sequenceStart = new SequencePosition(text, ReadOnlySequence.StringToSequenceStart(start));
_sequenceEnd = new SequencePosition(text, ReadOnlySequence.StringToSequenceEnd(start + length));
_startObject = text;
_endObject = text;
_startInteger = ReadOnlySequence.StringToSequenceStart(start);
_endInteger = ReadOnlySequence.StringToSequenceEnd(start + length);
}
else
{
// Should never be reached
ThrowHelper.ThrowInvalidOperationException();
_sequenceStart = default;
_sequenceEnd = default;
_startObject = null;
_endObject = null;
_startInteger = 0;
_endInteger = 0;
}
}
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items.
/// </summary>
/// <param name="start">The index at which to begin this slice.</param>
/// <param name="length">The length of the slice</param>
/// <param name="length">The length of the slice.</param>
/// <returns>A slice that consists of <paramref name="length" /> elements from the current instance starting at index <paramref name="start" />.</returns>
public ReadOnlySequence<T> Slice(long start, long length)
{
if (start < 0 || length < 0)
@ -169,11 +199,11 @@ namespace System.Buffers
SequencePosition begin;
SequencePosition end;
int startIndex = GetIndex(_sequenceStart);
int endIndex = GetIndex(_sequenceEnd);
int startIndex = GetIndex(_startInteger);
int endIndex = GetIndex(_endInteger);
object startObject = _sequenceStart.GetObject();
object endObject = _sequenceEnd.GetObject();
object startObject = _startObject;
object endObject = _endObject;
if (startObject != endObject)
{
@ -232,23 +262,30 @@ namespace System.Buffers
}
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, ending at <paramref name="end"/> (inclusive).
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/> and ending at <paramref name="end"/> (exclusive).
/// </summary>
/// <param name="start">The index at which to begin this slice.</param>
/// <param name="end">The end (inclusive) of the slice</param>
/// <param name="end">The ending (exclusive) <see cref="SequencePosition"/> of the slice.</param>
/// <returns>A slice that consists of items from the <paramref name="start" /> index to, but not including, the <paramref name="end" /> sequence position in the current read-only sequence.</returns>
public ReadOnlySequence<T> Slice(long start, SequencePosition end)
{
if (start < 0)
ThrowHelper.ThrowStartOrEndArgumentValidationException(start);
uint startIndex = (uint)GetIndex(_startInteger);
object startObject = _startObject;
uint endIndex = (uint)GetIndex(_endInteger);
object endObject = _endObject;
uint sliceEndIndex = (uint)GetIndex(end);
object sliceEndObject = end.GetObject();
uint startIndex = (uint)GetIndex(_sequenceStart);
object startObject = _sequenceStart.GetObject();
uint endIndex = (uint)GetIndex(_sequenceEnd);
object endObject = _sequenceEnd.GetObject();
if (sliceEndObject == null)
{
sliceEndObject = _startObject;
sliceEndIndex = startIndex;
}
// Single-Segment Sequence
if (startObject == endObject)
@ -300,25 +337,32 @@ namespace System.Buffers
FoundInFirstSegment:
// startIndex + start <= int.MaxValue
Debug.Assert(start <= int.MaxValue - startIndex);
return SliceImpl(new SequencePosition(startObject, (int)startIndex + (int)start), end);
return SliceImpl(new SequencePosition(startObject, (int)startIndex + (int)start), new SequencePosition(sliceEndObject, (int)sliceEndIndex));
}
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items.
/// </summary>
/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</param>
/// <param name="length">The length of the slice</param>
/// <param name="length">The length of the slice.</param>
/// <returns>A slice that consists of <paramref name="length" /> elements from the current instance starting at sequence position <paramref name="start" />.</returns>
public ReadOnlySequence<T> Slice(SequencePosition start, long length)
{
uint startIndex = (uint)GetIndex(_startInteger);
object startObject = _startObject;
uint endIndex = (uint)GetIndex(_endInteger);
object endObject = _endObject;
// Check start before length
uint sliceStartIndex = (uint)GetIndex(start);
object sliceStartObject = start.GetObject();
uint startIndex = (uint)GetIndex(_sequenceStart);
object startObject = _sequenceStart.GetObject();
uint endIndex = (uint)GetIndex(_sequenceEnd);
object endObject = _sequenceEnd.GetObject();
if (sliceStartObject == null)
{
sliceStartIndex = startIndex;
sliceStartObject = _startObject;
}
// Single-Segment Sequence
if (startObject == endObject)
@ -376,35 +420,39 @@ namespace System.Buffers
FoundInFirstSegment:
// sliceStartIndex + length <= int.MaxValue
Debug.Assert(length <= int.MaxValue - sliceStartIndex);
return SliceImpl(start, new SequencePosition(sliceStartObject, (int)sliceStartIndex + (int)length));
return SliceImpl(new SequencePosition(sliceStartObject, (int)sliceStartIndex), new SequencePosition(sliceStartObject, (int)sliceStartIndex + (int)length));
}
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items.
/// </summary>
/// <param name="start">The index at which to begin this slice.</param>
/// <param name="length">The length of the slice</param>
/// <param name="length">The length of the slice.</param>
/// <returns>A slice that consists of <paramref name="length" /> elements from the current instance starting at index <paramref name="start" />.</returns>
public ReadOnlySequence<T> Slice(int start, int length) => Slice((long)start, length);
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, ending at <paramref name="end"/> (inclusive).
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/> and ending at <paramref name="end"/> (exclusive).
/// </summary>
/// <param name="start">The index at which to begin this slice.</param>
/// <param name="end">The end (inclusive) of the slice</param>
/// <param name="end">The ending (exclusive) <see cref="SequencePosition"/> of the slice.</param>
/// <returns>A slice that consists of items from the <paramref name="start" /> index to, but not including, the <paramref name="end" /> sequence position in the current read-only sequence.</returns>
public ReadOnlySequence<T> Slice(int start, SequencePosition end) => Slice((long)start, end);
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at '<paramref name="start"/>, with <paramref name="length"/> items
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, with <paramref name="length"/> items.
/// </summary>
/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</param>
/// <param name="length">The length of the slice</param>
/// <param name="length">The length of the slice.</param>
/// <returns>A slice that consists of <paramref name="length" /> elements from the current instance starting at sequence position <paramref name="start" />.</returns>
public ReadOnlySequence<T> Slice(SequencePosition start, int length) => Slice(start, (long)length);
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, ending at <paramref name="end"/> (inclusive).
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, ending at <paramref name="end"/> (exclusive).
/// </summary>
/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</param>
/// <param name="end">The ending (inclusive) <see cref="SequencePosition"/> of the slice</param>
/// <param name="end">The ending (exclusive) <see cref="SequencePosition"/> of the slice.</param>
/// <returns>A slice that consists of items from the <paramref name="start" /> sequence position to, but not including, the <paramref name="end" /> sequence position in the current read-only sequence.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ReadOnlySequence<T> Slice(SequencePosition start, SequencePosition end)
{
@ -413,20 +461,23 @@ namespace System.Buffers
}
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, ending at the existing <see cref="ReadOnlySequence{T}"/>'s end.
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}" />, beginning at a specified sequence position and continuing to the end of the read-only sequence.
/// </summary>
/// <param name="start">The starting (inclusive) <see cref="SequencePosition"/> at which to begin this slice.</param>
/// <returns>A slice starting at sequence position <paramref name="start" /> and continuing to the end of the current read-only sequence.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ReadOnlySequence<T> Slice(SequencePosition start)
{
BoundsCheck(start);
return SliceImpl(start, _sequenceEnd);
bool positionIsNotNull = start.GetObject() != null;
BoundsCheck(start, positionIsNotNull);
return SliceImpl(positionIsNotNull ? start : Start);
}
/// <summary>
/// Forms a slice out of the given <see cref="ReadOnlySequence{T}"/>, beginning at <paramref name="start"/>, ending at the existing <see cref="ReadOnlySequence{T}"/>'s end.
/// Forms a slice out of the current <see cref="ReadOnlySequence{T}" /> , beginning at a specified index and continuing to the end of the read-only sequence.
/// </summary>
/// <param name="start">The start index at which to begin this slice.</param>
/// <returns>A slice starting at index <paramref name="start" /> and continuing to the end of the current read-only sequence.</returns>
public ReadOnlySequence<T> Slice(long start)
{
if (start < 0)
@ -435,8 +486,8 @@ namespace System.Buffers
if (start == 0)
return this;
SequencePosition begin = Seek(_sequenceStart, _sequenceEnd, start, ExceptionArgument.start);
return SliceImpl(begin, _sequenceEnd);
SequencePosition begin = Seek(start, ExceptionArgument.start);
return SliceImpl(begin);
}
/// <inheritdoc />
@ -454,19 +505,7 @@ namespace System.Buffers
if (Length < int.MaxValue)
{
#if !FEATURE_PORTABLE_SPAN
return string.Create((int)Length, charSequence, (span, sequence) =>
{
foreach (ReadOnlyMemory<char> readOnlyMemory in sequence)
{
ReadOnlySpan<char> sourceSpan = readOnlyMemory.Span;
sourceSpan.CopyTo(span);
span = span.Slice(sourceSpan.Length);
}
});
#else
return new string(charSequence.ToArray());
#endif
return string.Create((int)Length, charSequence, (span, sequence) => sequence.CopyTo(span));
}
}
@ -481,7 +520,13 @@ namespace System.Buffers
/// <summary>
/// Returns a new <see cref="SequencePosition"/> at an <paramref name="offset"/> from the start of the sequence.
/// </summary>
public SequencePosition GetPosition(long offset) => GetPosition(offset, _sequenceStart);
public SequencePosition GetPosition(long offset)
{
if (offset < 0)
ThrowHelper.ThrowArgumentOutOfRangeException_OffsetOutOfRange();
return Seek(offset);
}
/// <summary>
/// Returns a new <see cref="SequencePosition"/> at an <paramref name="offset"/> from the <paramref name="origin"/>
@ -491,7 +536,7 @@ namespace System.Buffers
if (offset < 0)
ThrowHelper.ThrowArgumentOutOfRangeException_OffsetOutOfRange();
return Seek(origin, _sequenceEnd, offset, ExceptionArgument.offset);
return Seek(origin, offset);
}
/// <summary>
@ -592,4 +637,4 @@ namespace System.Buffers
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int StringToSequenceEnd(int endIndex) => endIndex | StringEndMask;
}
}
}

392
external/corefx/src/System.Memory/src/System/Buffers/ReadOnlySequence_helpers.cs vendored
View File

File diff suppressed because it is too large Load Diff

109
external/corefx/src/System.Memory/src/System/Buffers/StandardFormat.cs vendored
View File

@ -67,12 +67,34 @@ namespace System.Buffers
public static implicit operator StandardFormat(char symbol) => new StandardFormat(symbol);
/// <summary>
/// Converts a classic .NET format string into a StandardFormat
/// Converts a <see cref="ReadOnlySpan{Char}"/> into a StandardFormat
/// </summary>
public static StandardFormat Parse(ReadOnlySpan<char> format)
{
ParseHelper(format, out StandardFormat standardFormat, throws: true);
return standardFormat;
}
/// <summary>
/// Converts a classic .NET format string into a StandardFormat
/// </summary>
public static StandardFormat Parse(string format) => format == null ? default : Parse(format.AsSpan());
/// <summary>
/// Tries to convert a <see cref="ReadOnlySpan{Char}"/> into a StandardFormat. A return value indicates whether the conversion succeeded or failed.
/// </summary>
public static bool TryParse(ReadOnlySpan<char> format, out StandardFormat result)
{
return ParseHelper(format, out result);
}
private static bool ParseHelper(ReadOnlySpan<char> format, out StandardFormat standardFormat, bool throws = false)
{
standardFormat = default;
if (format.Length == 0)
return default;
return true;
char symbol = format[0];
byte precision;
@ -87,24 +109,23 @@ namespace System.Buffers
{
uint digit = format[srcIndex] - 48u; // '0'
if (digit > 9)
throw new FormatException(SR.Format(SR.Argument_CannotParsePrecision, MaxPrecision));
{
return throws ? throw new FormatException(SR.Format(SR.Argument_CannotParsePrecision, MaxPrecision)) : false;
}
parsedPrecision = parsedPrecision * 10 + digit;
if (parsedPrecision > MaxPrecision)
throw new FormatException(SR.Format(SR.Argument_PrecisionTooLarge, MaxPrecision));
{
return throws ? throw new FormatException(SR.Format(SR.Argument_PrecisionTooLarge, MaxPrecision)) : false;
}
}
precision = (byte)parsedPrecision;
}
return new StandardFormat(symbol, precision);
standardFormat = new StandardFormat(symbol, precision);
return true;
}
/// <summary>
/// Converts a classic .NET format string into a StandardFormat
/// </summary>
public static StandardFormat Parse(string format) => format == null ? default : Parse(format.AsSpan());
/// <summary>
/// Returns true if both the Symbol and Precision are equal.
/// </summary>
@ -125,40 +146,54 @@ namespace System.Buffers
/// </summary>
public override string ToString()
{
unsafe
Span<char> buffer = stackalloc char[FormatStringLength];
int charsWritten = Format(buffer);
return new string(buffer.Slice(0, charsWritten));
}
/// <summary>The exact buffer length required by <see cref="Format"/>.</summary>
internal const int FormatStringLength = 3;
/// <summary>
/// Formats the format in classic .NET format.
/// </summary>
internal int Format(Span<char> destination)
{
Debug.Assert(destination.Length == FormatStringLength);
int count = 0;
char symbol = Symbol;
if (symbol != default &&
(uint)destination.Length == FormatStringLength) // to eliminate bounds checks
{
const int MaxLength = 4;
char* pBuffer = stackalloc char[MaxLength];
destination[0] = symbol;
count = 1;
int dstIndex = 0;
char symbol = Symbol;
if (symbol != default)
uint precision = Precision;
if (precision != NoPrecision)
{
pBuffer[dstIndex++] = symbol;
// Note that Precision is stored as a byte, so in theory it could contain
// values > MaxPrecision (99). But all supported mechanisms for creating a
// StandardFormat limit values to being <= MaxPrecision, so the only way a value
// could be larger than that is if unsafe code or the equivalent were used
// to force a larger invalid value in, in which case we don't need to
// guarantee such an invalid value is properly roundtripped through here;
// we just need to make sure things aren't corrupted further.
byte precision = Precision;
if (precision != NoPrecision)
if (precision >= 10)
{
if (precision >= 100)
{
pBuffer[dstIndex++] = (char)('0' + (precision / 100) % 10);
precision = (byte)(precision % 100);
}
if (precision >= 10)
{
pBuffer[dstIndex++] = (char)('0' + (precision / 10) % 10);
precision = (byte)(precision % 10);
}
pBuffer[dstIndex++] = (char)('0' + precision);
uint div = Math.DivRem(precision, 10, out precision);
destination[1] = (char)('0' + div % 10);
count = 2;
}
destination[count] = (char)('0' + precision);
count++;
}
Debug.Assert(dstIndex <= MaxLength);
return new string(pBuffer, startIndex: 0, length: dstIndex);
}
return count;
}
/// <summary>

24
external/corefx/src/System.Memory/src/System/Runtime/InteropServices/SequenceMarshal.cs vendored
View File

@ -57,5 +57,29 @@ namespace System.Runtime.InteropServices
{
return sequence.TryGetString(out text, out start, out length);
}
/// <summary>
/// Try to read the given type out of the buffer if possible. Warning: this is dangerous to use with arbitrary
/// structs- see remarks for full details.
/// </summary>
/// <remarks>
/// IMPORTANT: The read is a straight copy of bits. If a struct depends on specific state of it's members to
/// behave correctly this can lead to exceptions, etc. If reading endian specific integers, use the explicit
/// overloads such as <see cref="SequenceReaderExtensions.TryReadLittleEndian(ref SequenceReader{byte}, out int)"/>
/// </remarks>
/// <returns>
/// True if successful. <paramref name="value"/> will be default if failed (due to lack of space).
/// </returns>
#if __MonoCS__
public static bool TryRead<T>(ref SequenceReader<byte> reader, out T value)
{
throw new PlatformNotSupportedException();
}
#else
public static bool TryRead<T>(ref SequenceReader<byte> reader, out T value) where T : unmanaged
{
return reader.TryRead<T>(out value);
}
#endif
}
}

2
mcs/build/common/Consts.cs
View File

@ -41,7 +41,7 @@ static partial class Consts
// Use these assembly version constants to make code more maintainable.
//
public const string MonoVersion = "6.6.0.102";
public const string MonoVersion = "6.6.0.103";
public const string MonoCompany = "Mono development team";
public const string MonoProduct = "Mono Common Language Infrastructure";
public const string MonoCopyright = "(c) Various Mono authors";

Some files were not shown because too many files have changed in this diff Show More