netcore/System.Private.CoreLib/shared/System/Tuple.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Collections;
   6 using System.Collections.Generic;
   7 using System.Diagnostics;
   8 using System.Runtime.CompilerServices;
   9 using System.Text;
  10
  11 //
  12 // Note: F# compiler depends on the exact tuple hashing algorithm. Do not ever change it.
  13 //
  14
  15 namespace System
  16 {
  17     /// <summary>
  18     /// Helper so we can call some tuple methods recursively without knowing the underlying types.
  19     /// </summary>
  20     internal interface ITupleInternal : ITuple
  21     {
  22         string ToString(StringBuilder sb);
  23         int GetHashCode(IEqualityComparer comparer);
  24     }
  25
  26     public static class Tuple
  27     {
  28         public static Tuple<T1> Create<T1>(T1 item1)
  29         {
  30             return new Tuple<T1>(item1);
  31         }
  32
  33         public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
  34         {
  35             return new Tuple<T1, T2>(item1, item2);
  36         }
  37
  38         public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
  39         {
  40             return new Tuple<T1, T2, T3>(item1, item2, item3);
  41         }
  42
  43         public static Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4)
  44         {
  45             return new Tuple<T1, T2, T3, T4>(item1, item2, item3, item4);
  46         }
  47
  48         public static Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
  49         {
  50             return new Tuple<T1, T2, T3, T4, T5>(item1, item2, item3, item4, item5);
  51         }
  52
  53         public static Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
  54         {
  55             return new Tuple<T1, T2, T3, T4, T5, T6>(item1, item2, item3, item4, item5, item6);
  56         }
  57
  58         public static Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
  59         {
  60             return new Tuple<T1, T2, T3, T4, T5, T6, T7>(item1, item2, item3, item4, item5, item6, item7);
  61         }
  62
  63         public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
  64         {
  65             return new Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>(item1, item2, item3, item4, item5, item6, item7, new Tuple<T8>(item8));
  66         }
  67
  68         // From System.Web.Util.HashCodeCombiner
  69         internal static int CombineHashCodes(int h1, int h2)
  70         {
  71             return (((h1 << 5) + h1) ^ h2);
  72         }
  73
  74         internal static int CombineHashCodes(int h1, int h2, int h3)
  75         {
  76             return CombineHashCodes(CombineHashCodes(h1, h2), h3);
  77         }
  78
  79         internal static int CombineHashCodes(int h1, int h2, int h3, int h4)
  80         {
  81             return CombineHashCodes(CombineHashCodes(h1, h2), CombineHashCodes(h3, h4));
  82         }
  83
  84         internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5)
  85         {
  86             return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), h5);
  87         }
  88
  89         internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6)
  90         {
  91             return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6));
  92         }
  93
  94         internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6, int h7)
  95         {
  96             return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6, h7));
  97         }
  98
  99         internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6, int h7, int h8)
 100         {
 101             return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6, h7, h8));
 102         }
 103     }
 104
 105     [Serializable]
 106     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 107     public class Tuple<T1> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 108     {
 109         private readonly T1 m_Item1; // Do not rename (binary serialization)
 110
 111         public T1 Item1 => m_Item1;
 112
 113         public Tuple(T1 item1)
 114         {
 115             m_Item1 = item1;
 116         }
 117
 118         public override bool Equals(object? obj)
 119         {
 120             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default);
 121         }
 122
 123         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 124         {
 125             if (other == null) return false;
 126
 127             if (!(other is Tuple<T1> objTuple))
 128             {
 129                 return false;
 130             }
 131
 132             return comparer.Equals(m_Item1, objTuple.m_Item1);
 133         }
 134
 135         int IComparable.CompareTo(object? obj)
 136         {
 137             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 138         }
 139
 140         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 141         {
 142             if (other == null) return 1;
 143
 144             if (!(other is Tuple<T1> objTuple))
 145             {
 146                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 147             }
 148
 149             return comparer.Compare(m_Item1, objTuple.m_Item1);
 150         }
 151
 152         public override int GetHashCode()
 153         {
 154             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 155         }
 156
 157         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 158         {
 159             return comparer.GetHashCode(m_Item1!);
 160         }
 161
 162         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 163         {
 164             return ((IStructuralEquatable)this).GetHashCode(comparer);
 165         }
 166         public override string ToString()
 167         {
 168             StringBuilder sb = new StringBuilder();
 169             sb.Append('(');
 170             return ((ITupleInternal)this).ToString(sb);
 171         }
 172
 173         string ITupleInternal.ToString(StringBuilder sb)
 174         {
 175             sb.Append(m_Item1);
 176             sb.Append(')');
 177             return sb.ToString();
 178         }
 179
 180         /// <summary>
 181         /// The number of positions in this data structure.
 182         /// </summary>
 183         int ITuple.Length => 1;
 184
 185         /// <summary>
 186         /// Get the element at position <param name="index"/>.
 187         /// </summary>
 188         object? ITuple.this[int index]
 189         {
 190             get
 191             {
 192                 if (index != 0)
 193                 {
 194                     throw new IndexOutOfRangeException();
 195                 }
 196                 return Item1;
 197             }
 198         }
 199     }
 200
 201     [Serializable]
 202     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 203     public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 204     {
 205         private readonly T1 m_Item1; // Do not rename (binary serialization)
 206         private readonly T2 m_Item2; // Do not rename (binary serialization)
 207
 208         public T1 Item1 => m_Item1;
 209         public T2 Item2 => m_Item2;
 210
 211         public Tuple(T1 item1, T2 item2)
 212         {
 213             m_Item1 = item1;
 214             m_Item2 = item2;
 215         }
 216
 217         public override bool Equals(object? obj)
 218         {
 219             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 220         }
 221
 222         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 223         {
 224             if (other == null) return false;
 225
 226             if (!(other is Tuple<T1, T2> objTuple))
 227             {
 228                 return false;
 229             }
 230
 231             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2);
 232         }
 233
 234         int IComparable.CompareTo(object? obj)
 235         {
 236             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 237         }
 238
 239         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 240         {
 241             if (other == null) return 1;
 242
 243             if (!(other is Tuple<T1, T2> objTuple))
 244             {
 245                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 246             }
 247
 248             int c = 0;
 249
 250             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 251
 252             if (c != 0) return c;
 253
 254             return comparer.Compare(m_Item2, objTuple.m_Item2);
 255         }
 256
 257         public override int GetHashCode()
 258         {
 259             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 260         }
 261
 262         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 263         {
 264             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!));
 265         }
 266
 267         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 268         {
 269             return ((IStructuralEquatable)this).GetHashCode(comparer);
 270         }
 271         public override string ToString()
 272         {
 273             StringBuilder sb = new StringBuilder();
 274             sb.Append('(');
 275             return ((ITupleInternal)this).ToString(sb);
 276         }
 277
 278         string ITupleInternal.ToString(StringBuilder sb)
 279         {
 280             sb.Append(m_Item1);
 281             sb.Append(", ");
 282             sb.Append(m_Item2);
 283             sb.Append(')');
 284             return sb.ToString();
 285         }
 286
 287         /// <summary>
 288         /// The number of positions in this data structure.
 289         /// </summary>
 290         int ITuple.Length => 2;
 291
 292         /// <summary>
 293         /// Get the element at position <param name="index"/>.
 294         /// </summary>
 295         object? ITuple.this[int index]
 296         {
 297             get
 298             {
 299                 return index switch
 300                 {
 301                     0 => Item1,
 302                     1 => Item2,
 303                     _ => throw new IndexOutOfRangeException(),
 304                 };
 305             }
 306         }
 307     }
 308
 309     [Serializable]
 310     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 311     public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 312     {
 313         private readonly T1 m_Item1; // Do not rename (binary serialization)
 314         private readonly T2 m_Item2; // Do not rename (binary serialization)
 315         private readonly T3 m_Item3; // Do not rename (binary serialization)
 316
 317         public T1 Item1 => m_Item1;
 318         public T2 Item2 => m_Item2;
 319         public T3 Item3 => m_Item3;
 320
 321         public Tuple(T1 item1, T2 item2, T3 item3)
 322         {
 323             m_Item1 = item1;
 324             m_Item2 = item2;
 325             m_Item3 = item3;
 326         }
 327
 328         public override bool Equals(object? obj)
 329         {
 330             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 331         }
 332
 333         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 334         {
 335             if (other == null) return false;
 336
 337             if (!(other is Tuple<T1, T2, T3> objTuple))
 338             {
 339                 return false;
 340             }
 341
 342             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3);
 343         }
 344
 345         int IComparable.CompareTo(object? obj)
 346         {
 347             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 348         }
 349
 350         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 351         {
 352             if (other == null) return 1;
 353
 354             if (!(other is Tuple<T1, T2, T3> objTuple))
 355             {
 356                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 357             }
 358
 359             int c = 0;
 360
 361             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 362
 363             if (c != 0) return c;
 364
 365             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 366
 367             if (c != 0) return c;
 368
 369             return comparer.Compare(m_Item3, objTuple.m_Item3);
 370         }
 371
 372         public override int GetHashCode()
 373         {
 374             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 375         }
 376
 377         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 378         {
 379             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!));
 380         }
 381
 382         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 383         {
 384             return ((IStructuralEquatable)this).GetHashCode(comparer);
 385         }
 386         public override string ToString()
 387         {
 388             StringBuilder sb = new StringBuilder();
 389             sb.Append('(');
 390             return ((ITupleInternal)this).ToString(sb);
 391         }
 392
 393         string ITupleInternal.ToString(StringBuilder sb)
 394         {
 395             sb.Append(m_Item1);
 396             sb.Append(", ");
 397             sb.Append(m_Item2);
 398             sb.Append(", ");
 399             sb.Append(m_Item3);
 400             sb.Append(')');
 401             return sb.ToString();
 402         }
 403
 404         /// <summary>
 405         /// The number of positions in this data structure.
 406         /// </summary>
 407         int ITuple.Length => 3;
 408
 409         /// <summary>
 410         /// Get the element at position <param name="index"/>.
 411         /// </summary>
 412         object? ITuple.this[int index]
 413         {
 414             get
 415             {
 416                 return index switch
 417                 {
 418                     0 => Item1,
 419                     1 => Item2,
 420                     2 => Item3,
 421                     _ => throw new IndexOutOfRangeException(),
 422                 };
 423             }
 424         }
 425     }
 426
 427     [Serializable]
 428     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 429     public class Tuple<T1, T2, T3, T4> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 430     {
 431         private readonly T1 m_Item1; // Do not rename (binary serialization)
 432         private readonly T2 m_Item2; // Do not rename (binary serialization)
 433         private readonly T3 m_Item3; // Do not rename (binary serialization)
 434         private readonly T4 m_Item4; // Do not rename (binary serialization)
 435
 436         public T1 Item1 => m_Item1;
 437         public T2 Item2 => m_Item2;
 438         public T3 Item3 => m_Item3;
 439         public T4 Item4 => m_Item4;
 440
 441         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4)
 442         {
 443             m_Item1 = item1;
 444             m_Item2 = item2;
 445             m_Item3 = item3;
 446             m_Item4 = item4;
 447         }
 448
 449         public override bool Equals(object? obj)
 450         {
 451             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 452         }
 453
 454         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 455         {
 456             if (other == null) return false;
 457
 458             if (!(other is Tuple<T1, T2, T3, T4> objTuple))
 459             {
 460                 return false;
 461             }
 462
 463             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4);
 464         }
 465
 466         int IComparable.CompareTo(object? obj)
 467         {
 468             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 469         }
 470
 471         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 472         {
 473             if (other == null) return 1;
 474
 475             if (!(other is Tuple<T1, T2, T3, T4> objTuple))
 476             {
 477                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 478             }
 479
 480             int c = 0;
 481
 482             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 483
 484             if (c != 0) return c;
 485
 486             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 487
 488             if (c != 0) return c;
 489
 490             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 491
 492             if (c != 0) return c;
 493
 494             return comparer.Compare(m_Item4, objTuple.m_Item4);
 495         }
 496
 497         public override int GetHashCode()
 498         {
 499             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 500         }
 501
 502         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 503         {
 504             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!));
 505         }
 506
 507         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 508         {
 509             return ((IStructuralEquatable)this).GetHashCode(comparer);
 510         }
 511         public override string ToString()
 512         {
 513             StringBuilder sb = new StringBuilder();
 514             sb.Append('(');
 515             return ((ITupleInternal)this).ToString(sb);
 516         }
 517
 518         string ITupleInternal.ToString(StringBuilder sb)
 519         {
 520             sb.Append(m_Item1);
 521             sb.Append(", ");
 522             sb.Append(m_Item2);
 523             sb.Append(", ");
 524             sb.Append(m_Item3);
 525             sb.Append(", ");
 526             sb.Append(m_Item4);
 527             sb.Append(')');
 528             return sb.ToString();
 529         }
 530
 531         /// <summary>
 532         /// The number of positions in this data structure.
 533         /// </summary>
 534         int ITuple.Length => 4;
 535
 536         /// <summary>
 537         /// Get the element at position <param name="index"/>.
 538         /// </summary>
 539         object? ITuple.this[int index]
 540         {
 541             get
 542             {
 543                 return index switch
 544                 {
 545                     0 => Item1,
 546                     1 => Item2,
 547                     2 => Item3,
 548                     3 => Item4,
 549                     _ => throw new IndexOutOfRangeException(),
 550                 };
 551             }
 552         }
 553     }
 554
 555     [Serializable]
 556     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 557     public class Tuple<T1, T2, T3, T4, T5> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 558     {
 559         private readonly T1 m_Item1; // Do not rename (binary serialization)
 560         private readonly T2 m_Item2; // Do not rename (binary serialization)
 561         private readonly T3 m_Item3; // Do not rename (binary serialization)
 562         private readonly T4 m_Item4; // Do not rename (binary serialization)
 563         private readonly T5 m_Item5; // Do not rename (binary serialization)
 564
 565         public T1 Item1 => m_Item1;
 566         public T2 Item2 => m_Item2;
 567         public T3 Item3 => m_Item3;
 568         public T4 Item4 => m_Item4;
 569         public T5 Item5 => m_Item5;
 570
 571         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
 572         {
 573             m_Item1 = item1;
 574             m_Item2 = item2;
 575             m_Item3 = item3;
 576             m_Item4 = item4;
 577             m_Item5 = item5;
 578         }
 579
 580         public override bool Equals(object? obj)
 581         {
 582             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 583         }
 584
 585         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 586         {
 587             if (other == null) return false;
 588
 589             if (!(other is Tuple<T1, T2, T3, T4, T5> objTuple))
 590             {
 591                 return false;
 592             }
 593
 594             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5);
 595         }
 596
 597         int IComparable.CompareTo(object? obj)
 598         {
 599             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 600         }
 601
 602         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 603         {
 604             if (other == null) return 1;
 605
 606             if (!(other is Tuple<T1, T2, T3, T4, T5> objTuple))
 607             {
 608                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 609             }
 610
 611             int c = 0;
 612
 613             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 614
 615             if (c != 0) return c;
 616
 617             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 618
 619             if (c != 0) return c;
 620
 621             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 622
 623             if (c != 0) return c;
 624
 625             c = comparer.Compare(m_Item4, objTuple.m_Item4);
 626
 627             if (c != 0) return c;
 628
 629             return comparer.Compare(m_Item5, objTuple.m_Item5);
 630         }
 631
 632         public override int GetHashCode()
 633         {
 634             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 635         }
 636
 637         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 638         {
 639             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!));
 640         }
 641
 642         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 643         {
 644             return ((IStructuralEquatable)this).GetHashCode(comparer);
 645         }
 646         public override string ToString()
 647         {
 648             StringBuilder sb = new StringBuilder();
 649             sb.Append('(');
 650             return ((ITupleInternal)this).ToString(sb);
 651         }
 652
 653         string ITupleInternal.ToString(StringBuilder sb)
 654         {
 655             sb.Append(m_Item1);
 656             sb.Append(", ");
 657             sb.Append(m_Item2);
 658             sb.Append(", ");
 659             sb.Append(m_Item3);
 660             sb.Append(", ");
 661             sb.Append(m_Item4);
 662             sb.Append(", ");
 663             sb.Append(m_Item5);
 664             sb.Append(')');
 665             return sb.ToString();
 666         }
 667
 668         /// <summary>
 669         /// The number of positions in this data structure.
 670         /// </summary>
 671         int ITuple.Length => 5;
 672
 673         /// <summary>
 674         /// Get the element at position <param name="index"/>.
 675         /// </summary>
 676         object? ITuple.this[int index]
 677         {
 678             get
 679             {
 680                 return index switch
 681                 {
 682                     0 => Item1,
 683                     1 => Item2,
 684                     2 => Item3,
 685                     3 => Item4,
 686                     4 => Item5,
 687                     _ => throw new IndexOutOfRangeException(),
 688                 };
 689             }
 690         }
 691     }
 692
 693     [Serializable]
 694     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 695     public class Tuple<T1, T2, T3, T4, T5, T6> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 696     {
 697         private readonly T1 m_Item1; // Do not rename (binary serialization)
 698         private readonly T2 m_Item2; // Do not rename (binary serialization)
 699         private readonly T3 m_Item3; // Do not rename (binary serialization)
 700         private readonly T4 m_Item4; // Do not rename (binary serialization)
 701         private readonly T5 m_Item5; // Do not rename (binary serialization)
 702         private readonly T6 m_Item6; // Do not rename (binary serialization)
 703
 704         public T1 Item1 => m_Item1;
 705         public T2 Item2 => m_Item2;
 706         public T3 Item3 => m_Item3;
 707         public T4 Item4 => m_Item4;
 708         public T5 Item5 => m_Item5;
 709         public T6 Item6 => m_Item6;
 710
 711         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
 712         {
 713             m_Item1 = item1;
 714             m_Item2 = item2;
 715             m_Item3 = item3;
 716             m_Item4 = item4;
 717             m_Item5 = item5;
 718             m_Item6 = item6;
 719         }
 720
 721         public override bool Equals(object? obj)
 722         {
 723             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 724         }
 725
 726         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 727         {
 728             if (other == null) return false;
 729
 730             if (!(other is Tuple<T1, T2, T3, T4, T5, T6> objTuple))
 731             {
 732                 return false;
 733             }
 734
 735             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6);
 736         }
 737
 738         int IComparable.CompareTo(object? obj)
 739         {
 740             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 741         }
 742
 743         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 744         {
 745             if (other == null) return 1;
 746
 747             if (!(other is Tuple<T1, T2, T3, T4, T5, T6> objTuple))
 748             {
 749                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 750             }
 751
 752             int c = 0;
 753
 754             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 755
 756             if (c != 0) return c;
 757
 758             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 759
 760             if (c != 0) return c;
 761
 762             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 763
 764             if (c != 0) return c;
 765
 766             c = comparer.Compare(m_Item4, objTuple.m_Item4);
 767
 768             if (c != 0) return c;
 769
 770             c = comparer.Compare(m_Item5, objTuple.m_Item5);
 771
 772             if (c != 0) return c;
 773
 774             return comparer.Compare(m_Item6, objTuple.m_Item6);
 775         }
 776
 777         public override int GetHashCode()
 778         {
 779             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 780         }
 781
 782         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 783         {
 784             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!));
 785         }
 786
 787         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 788         {
 789             return ((IStructuralEquatable)this).GetHashCode(comparer);
 790         }
 791         public override string ToString()
 792         {
 793             StringBuilder sb = new StringBuilder();
 794             sb.Append('(');
 795             return ((ITupleInternal)this).ToString(sb);
 796         }
 797
 798         string ITupleInternal.ToString(StringBuilder sb)
 799         {
 800             sb.Append(m_Item1);
 801             sb.Append(", ");
 802             sb.Append(m_Item2);
 803             sb.Append(", ");
 804             sb.Append(m_Item3);
 805             sb.Append(", ");
 806             sb.Append(m_Item4);
 807             sb.Append(", ");
 808             sb.Append(m_Item5);
 809             sb.Append(", ");
 810             sb.Append(m_Item6);
 811             sb.Append(')');
 812             return sb.ToString();
 813         }
 814
 815         /// <summary>
 816         /// The number of positions in this data structure.
 817         /// </summary>
 818         int ITuple.Length => 6;
 819
 820         /// <summary>
 821         /// Get the element at position <param name="index"/>.
 822         /// </summary>
 823         object? ITuple.this[int index]
 824         {
 825             get
 826             {
 827                 return index switch
 828                 {
 829                     0 => Item1,
 830                     1 => Item2,
 831                     2 => Item3,
 832                     3 => Item4,
 833                     4 => Item5,
 834                     5 => Item6,
 835                     _ => throw new IndexOutOfRangeException(),
 836                 };
 837             }
 838         }
 839     }
 840
 841     [Serializable]
 842     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 843     public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 844     {
 845         private readonly T1 m_Item1; // Do not rename (binary serialization)
 846         private readonly T2 m_Item2; // Do not rename (binary serialization)
 847         private readonly T3 m_Item3; // Do not rename (binary serialization)
 848         private readonly T4 m_Item4; // Do not rename (binary serialization)
 849         private readonly T5 m_Item5; // Do not rename (binary serialization)
 850         private readonly T6 m_Item6; // Do not rename (binary serialization)
 851         private readonly T7 m_Item7; // Do not rename (binary serialization)
 852
 853         public T1 Item1 => m_Item1;
 854         public T2 Item2 => m_Item2;
 855         public T3 Item3 => m_Item3;
 856         public T4 Item4 => m_Item4;
 857         public T5 Item5 => m_Item5;
 858         public T6 Item6 => m_Item6;
 859         public T7 Item7 => m_Item7;
 860
 861         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
 862         {
 863             m_Item1 = item1;
 864             m_Item2 = item2;
 865             m_Item3 = item3;
 866             m_Item4 = item4;
 867             m_Item5 = item5;
 868             m_Item6 = item6;
 869             m_Item7 = item7;
 870         }
 871
 872         public override bool Equals(object? obj)
 873         {
 874             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 875         }
 876
 877         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 878         {
 879             if (other == null) return false;
 880
 881             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7> objTuple))
 882             {
 883                 return false;
 884             }
 885
 886             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6) && comparer.Equals(m_Item7, objTuple.m_Item7);
 887         }
 888
 889         int IComparable.CompareTo(object? obj)
 890         {
 891             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 892         }
 893
 894         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 895         {
 896             if (other == null) return 1;
 897
 898             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7> objTuple))
 899             {
 900                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 901             }
 902
 903             int c = 0;
 904
 905             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 906
 907             if (c != 0) return c;
 908
 909             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 910
 911             if (c != 0) return c;
 912
 913             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 914
 915             if (c != 0) return c;
 916
 917             c = comparer.Compare(m_Item4, objTuple.m_Item4);
 918
 919             if (c != 0) return c;
 920
 921             c = comparer.Compare(m_Item5, objTuple.m_Item5);
 922
 923             if (c != 0) return c;
 924
 925             c = comparer.Compare(m_Item6, objTuple.m_Item6);
 926
 927             if (c != 0) return c;
 928
 929             return comparer.Compare(m_Item7, objTuple.m_Item7);
 930         }
 931
 932         public override int GetHashCode()
 933         {
 934             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 935         }
 936
 937         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 938         {
 939             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!));
 940         }
 941
 942         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 943         {
 944             return ((IStructuralEquatable)this).GetHashCode(comparer);
 945         }
 946         public override string ToString()
 947         {
 948             StringBuilder sb = new StringBuilder();
 949             sb.Append('(');
 950             return ((ITupleInternal)this).ToString(sb);
 951         }
 952
 953         string ITupleInternal.ToString(StringBuilder sb)
 954         {
 955             sb.Append(m_Item1);
 956             sb.Append(", ");
 957             sb.Append(m_Item2);
 958             sb.Append(", ");
 959             sb.Append(m_Item3);
 960             sb.Append(", ");
 961             sb.Append(m_Item4);
 962             sb.Append(", ");
 963             sb.Append(m_Item5);
 964             sb.Append(", ");
 965             sb.Append(m_Item6);
 966             sb.Append(", ");
 967             sb.Append(m_Item7);
 968             sb.Append(')');
 969             return sb.ToString();
 970         }
 971
 972         /// <summary>
 973         /// The number of positions in this data structure.
 974         /// </summary>
 975         int ITuple.Length => 7;
 976
 977         /// <summary>
 978         /// Get the element at position <param name="index"/>.
 979         /// </summary>
 980         object? ITuple.this[int index]
 981         {
 982             get
 983             {
 984                 return index switch
 985                 {
 986                     0 => Item1,
 987                     1 => Item2,
 988                     2 => Item3,
 989                     3 => Item4,
 990                     4 => Item5,
 991                     5 => Item6,
 992                     6 => Item7,
 993                     _ => throw new IndexOutOfRangeException(),
 994                 };
 995             }
 996         }
 997     }
 998
 999     [Serializable]
1000     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
1001     public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple where TRest : notnull
1002     {
1003         private readonly T1 m_Item1; // Do not rename (binary serialization)
1004         private readonly T2 m_Item2; // Do not rename (binary serialization)
1005         private readonly T3 m_Item3; // Do not rename (binary serialization)
1006         private readonly T4 m_Item4; // Do not rename (binary serialization)
1007         private readonly T5 m_Item5; // Do not rename (binary serialization)
1008         private readonly T6 m_Item6; // Do not rename (binary serialization)
1009         private readonly T7 m_Item7; // Do not rename (binary serialization)
1010         private readonly TRest m_Rest; // Do not rename (binary serialization)
1011
1012         public T1 Item1 => m_Item1;
1013         public T2 Item2 => m_Item2;
1014         public T3 Item3 => m_Item3;
1015         public T4 Item4 => m_Item4;
1016         public T5 Item5 => m_Item5;
1017         public T6 Item6 => m_Item6;
1018         public T7 Item7 => m_Item7;
1019         public TRest Rest => m_Rest;
1020
1021         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
1022         {
1023             if (!(rest is ITupleInternal))
1024             {
1025                 throw new ArgumentException(SR.ArgumentException_TupleLastArgumentNotATuple);
1026             }
1027
1028             m_Item1 = item1;
1029             m_Item2 = item2;
1030             m_Item3 = item3;
1031             m_Item4 = item4;
1032             m_Item5 = item5;
1033             m_Item6 = item6;
1034             m_Item7 = item7;
1035             m_Rest = rest;
1036         }
1037
1038         public override bool Equals(object? obj)
1039         {
1040             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
1041         }
1042
1043         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
1044         {
1045             if (other == null) return false;
1046
1047             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> objTuple))
1048             {
1049                 return false;
1050             }
1051
1052             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6) && comparer.Equals(m_Item7, objTuple.m_Item7) && comparer.Equals(m_Rest, objTuple.m_Rest);
1053         }
1054
1055         int IComparable.CompareTo(object? obj)
1056         {
1057             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
1058         }
1059
1060         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
1061         {
1062             if (other == null) return 1;
1063
1064             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> objTuple))
1065             {
1066                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
1067             }
1068
1069             int c = 0;
1070
1071             c = comparer.Compare(m_Item1, objTuple.m_Item1);
1072
1073             if (c != 0) return c;
1074
1075             c = comparer.Compare(m_Item2, objTuple.m_Item2);
1076
1077             if (c != 0) return c;
1078
1079             c = comparer.Compare(m_Item3, objTuple.m_Item3);
1080
1081             if (c != 0) return c;
1082
1083             c = comparer.Compare(m_Item4, objTuple.m_Item4);
1084
1085             if (c != 0) return c;
1086
1087             c = comparer.Compare(m_Item5, objTuple.m_Item5);
1088
1089             if (c != 0) return c;
1090
1091             c = comparer.Compare(m_Item6, objTuple.m_Item6);
1092
1093             if (c != 0) return c;
1094
1095             c = comparer.Compare(m_Item7, objTuple.m_Item7);
1096
1097             if (c != 0) return c;
1098
1099             return comparer.Compare(m_Rest, objTuple.m_Rest);
1100         }
1101
1102         public override int GetHashCode()
1103         {
1104             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
1105         }
1106
1107         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
1108         {
1109             // We want to have a limited hash in this case.  We'll use the last 8 elements of the tuple
1110             ITupleInternal t = (ITupleInternal)m_Rest;
1111             if (t.Length >= 8) { return t.GetHashCode(comparer); }
1112
1113             // In this case, the rest memeber has less than 8 elements so we need to combine some our elements with the elements in rest
1114             int k = 8 - t.Length;
1115             switch (k)
1116             {
1117                 case 1:
1118                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1119                 case 2:
1120                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1121                 case 3:
1122                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1123                 case 4:
1124                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1125                 case 5:
1126                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1127                 case 6:
1128                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1129                 case 7:
1130                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1131             }
1132             Debug.Fail("Missed all cases for computing Tuple hash code");
1133             return -1;
1134         }
1135
1136         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
1137         {
1138             return ((IStructuralEquatable)this).GetHashCode(comparer);
1139         }
1140         public override string ToString()
1141         {
1142             StringBuilder sb = new StringBuilder();
1143             sb.Append('(');
1144             return ((ITupleInternal)this).ToString(sb);
1145         }
1146
1147         string ITupleInternal.ToString(StringBuilder sb)
1148         {
1149             sb.Append(m_Item1);
1150             sb.Append(", ");
1151             sb.Append(m_Item2);
1152             sb.Append(", ");
1153             sb.Append(m_Item3);
1154             sb.Append(", ");
1155             sb.Append(m_Item4);
1156             sb.Append(", ");
1157             sb.Append(m_Item5);
1158             sb.Append(", ");
1159             sb.Append(m_Item6);
1160             sb.Append(", ");
1161             sb.Append(m_Item7);
1162             sb.Append(", ");
1163             return ((ITupleInternal)m_Rest).ToString(sb);
1164         }
1165
1166         /// <summary>
1167         /// The number of positions in this data structure.
1168         /// </summary>
1169         int ITuple.Length => 7 + ((ITupleInternal)Rest).Length;
1170
1171         /// <summary>
1172         /// Get the element at position <param name="index"/>.
1173         /// </summary>
1174         object? ITuple.this[int index]
1175         {
1176             get
1177             {
1178                 return index switch
1179                 {
1180                     0 => Item1,
1181                     1 => Item2,
1182                     2 => Item3,
1183                     3 => Item4,
1184                     4 => Item5,
1185                     5 => Item6,
1186                     6 => Item7,
1187
1188                     _ => ((ITupleInternal)Rest)[index - 7],
1189                 };
1190             }
1191         }
1192     }
1193 }