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