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 { get { return 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 { get { return m_Item1; } }
 209         public T2 Item2 { get { return 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                 switch (index)
 300                 {
 301                     case 0:
 302                         return Item1;
 303                     case 1:
 304                         return Item2;
 305                     default:
 306                         throw new IndexOutOfRangeException();
 307                 }
 308             }
 309         }
 310     }
 311
 312     [Serializable]
 313     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 314     public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 315     {
 316         private readonly T1 m_Item1; // Do not rename (binary serialization)
 317         private readonly T2 m_Item2; // Do not rename (binary serialization)
 318         private readonly T3 m_Item3; // Do not rename (binary serialization)
 319
 320         public T1 Item1 { get { return m_Item1; } }
 321         public T2 Item2 { get { return m_Item2; } }
 322         public T3 Item3 { get { return m_Item3; } }
 323
 324         public Tuple(T1 item1, T2 item2, T3 item3)
 325         {
 326             m_Item1 = item1;
 327             m_Item2 = item2;
 328             m_Item3 = item3;
 329         }
 330
 331         public override bool Equals(object? obj)
 332         {
 333             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 334         }
 335
 336         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 337         {
 338             if (other == null) return false;
 339
 340             if (!(other is Tuple<T1, T2, T3> objTuple))
 341             {
 342                 return false;
 343             }
 344
 345             return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3);
 346         }
 347
 348         int IComparable.CompareTo(object? obj)
 349         {
 350             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 351         }
 352
 353         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 354         {
 355             if (other == null) return 1;
 356
 357             if (!(other is Tuple<T1, T2, T3> objTuple))
 358             {
 359                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 360             }
 361
 362             int c = 0;
 363
 364             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 365
 366             if (c != 0) return c;
 367
 368             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 369
 370             if (c != 0) return c;
 371
 372             return comparer.Compare(m_Item3, objTuple.m_Item3);
 373         }
 374
 375         public override int GetHashCode()
 376         {
 377             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 378         }
 379
 380         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 381         {
 382             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!));
 383         }
 384
 385         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 386         {
 387             return ((IStructuralEquatable)this).GetHashCode(comparer);
 388         }
 389         public override string ToString()
 390         {
 391             StringBuilder sb = new StringBuilder();
 392             sb.Append('(');
 393             return ((ITupleInternal)this).ToString(sb);
 394         }
 395
 396         string ITupleInternal.ToString(StringBuilder sb)
 397         {
 398             sb.Append(m_Item1);
 399             sb.Append(", ");
 400             sb.Append(m_Item2);
 401             sb.Append(", ");
 402             sb.Append(m_Item3);
 403             sb.Append(')');
 404             return sb.ToString();
 405         }
 406
 407         /// <summary>
 408         /// The number of positions in this data structure.
 409         /// </summary>
 410         int ITuple.Length => 3;
 411
 412         /// <summary>
 413         /// Get the element at position <param name="index"/>.
 414         /// </summary>
 415         object? ITuple.this[int index]
 416         {
 417             get
 418             {
 419                 switch (index)
 420                 {
 421                     case 0:
 422                         return Item1;
 423                     case 1:
 424                         return Item2;
 425                     case 2:
 426                         return Item3;
 427                     default:
 428                         throw new IndexOutOfRangeException();
 429                 }
 430             }
 431         }
 432     }
 433
 434     [Serializable]
 435     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 436     public class Tuple<T1, T2, T3, T4> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 437     {
 438         private readonly T1 m_Item1; // Do not rename (binary serialization)
 439         private readonly T2 m_Item2; // Do not rename (binary serialization)
 440         private readonly T3 m_Item3; // Do not rename (binary serialization)
 441         private readonly T4 m_Item4; // Do not rename (binary serialization)
 442
 443         public T1 Item1 { get { return m_Item1; } }
 444         public T2 Item2 { get { return m_Item2; } }
 445         public T3 Item3 { get { return m_Item3; } }
 446         public T4 Item4 { get { return m_Item4; } }
 447
 448         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4)
 449         {
 450             m_Item1 = item1;
 451             m_Item2 = item2;
 452             m_Item3 = item3;
 453             m_Item4 = item4;
 454         }
 455
 456         public override bool Equals(object? obj)
 457         {
 458             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 459         }
 460
 461         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 462         {
 463             if (other == null) return false;
 464
 465             if (!(other is Tuple<T1, T2, T3, T4> objTuple))
 466             {
 467                 return false;
 468             }
 469
 470             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);
 471         }
 472
 473         int IComparable.CompareTo(object? obj)
 474         {
 475             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 476         }
 477
 478         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 479         {
 480             if (other == null) return 1;
 481
 482             if (!(other is Tuple<T1, T2, T3, T4> objTuple))
 483             {
 484                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 485             }
 486
 487             int c = 0;
 488
 489             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 490
 491             if (c != 0) return c;
 492
 493             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 494
 495             if (c != 0) return c;
 496
 497             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 498
 499             if (c != 0) return c;
 500
 501             return comparer.Compare(m_Item4, objTuple.m_Item4);
 502         }
 503
 504         public override int GetHashCode()
 505         {
 506             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 507         }
 508
 509         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 510         {
 511             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!));
 512         }
 513
 514         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 515         {
 516             return ((IStructuralEquatable)this).GetHashCode(comparer);
 517         }
 518         public override string ToString()
 519         {
 520             StringBuilder sb = new StringBuilder();
 521             sb.Append('(');
 522             return ((ITupleInternal)this).ToString(sb);
 523         }
 524
 525         string ITupleInternal.ToString(StringBuilder sb)
 526         {
 527             sb.Append(m_Item1);
 528             sb.Append(", ");
 529             sb.Append(m_Item2);
 530             sb.Append(", ");
 531             sb.Append(m_Item3);
 532             sb.Append(", ");
 533             sb.Append(m_Item4);
 534             sb.Append(')');
 535             return sb.ToString();
 536         }
 537
 538         /// <summary>
 539         /// The number of positions in this data structure.
 540         /// </summary>
 541         int ITuple.Length => 4;
 542
 543         /// <summary>
 544         /// Get the element at position <param name="index"/>.
 545         /// </summary>
 546         object? ITuple.this[int index]
 547         {
 548             get
 549             {
 550                 switch (index)
 551                 {
 552                     case 0:
 553                         return Item1;
 554                     case 1:
 555                         return Item2;
 556                     case 2:
 557                         return Item3;
 558                     case 3:
 559                         return Item4;
 560                     default:
 561                         throw new IndexOutOfRangeException();
 562                 }
 563             }
 564         }
 565     }
 566
 567     [Serializable]
 568     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 569     public class Tuple<T1, T2, T3, T4, T5> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 570     {
 571         private readonly T1 m_Item1; // Do not rename (binary serialization)
 572         private readonly T2 m_Item2; // Do not rename (binary serialization)
 573         private readonly T3 m_Item3; // Do not rename (binary serialization)
 574         private readonly T4 m_Item4; // Do not rename (binary serialization)
 575         private readonly T5 m_Item5; // Do not rename (binary serialization)
 576
 577         public T1 Item1 { get { return m_Item1; } }
 578         public T2 Item2 { get { return m_Item2; } }
 579         public T3 Item3 { get { return m_Item3; } }
 580         public T4 Item4 { get { return m_Item4; } }
 581         public T5 Item5 { get { return m_Item5; } }
 582
 583         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
 584         {
 585             m_Item1 = item1;
 586             m_Item2 = item2;
 587             m_Item3 = item3;
 588             m_Item4 = item4;
 589             m_Item5 = item5;
 590         }
 591
 592         public override bool Equals(object? obj)
 593         {
 594             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 595         }
 596
 597         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 598         {
 599             if (other == null) return false;
 600
 601             if (!(other is Tuple<T1, T2, T3, T4, T5> objTuple))
 602             {
 603                 return false;
 604             }
 605
 606             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);
 607         }
 608
 609         int IComparable.CompareTo(object? obj)
 610         {
 611             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 612         }
 613
 614         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 615         {
 616             if (other == null) return 1;
 617
 618             if (!(other is Tuple<T1, T2, T3, T4, T5> objTuple))
 619             {
 620                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 621             }
 622
 623             int c = 0;
 624
 625             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 626
 627             if (c != 0) return c;
 628
 629             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 630
 631             if (c != 0) return c;
 632
 633             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 634
 635             if (c != 0) return c;
 636
 637             c = comparer.Compare(m_Item4, objTuple.m_Item4);
 638
 639             if (c != 0) return c;
 640
 641             return comparer.Compare(m_Item5, objTuple.m_Item5);
 642         }
 643
 644         public override int GetHashCode()
 645         {
 646             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 647         }
 648
 649         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 650         {
 651             return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1!), comparer.GetHashCode(m_Item2!), comparer.GetHashCode(m_Item3!), comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!));
 652         }
 653
 654         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 655         {
 656             return ((IStructuralEquatable)this).GetHashCode(comparer);
 657         }
 658         public override string ToString()
 659         {
 660             StringBuilder sb = new StringBuilder();
 661             sb.Append('(');
 662             return ((ITupleInternal)this).ToString(sb);
 663         }
 664
 665         string ITupleInternal.ToString(StringBuilder sb)
 666         {
 667             sb.Append(m_Item1);
 668             sb.Append(", ");
 669             sb.Append(m_Item2);
 670             sb.Append(", ");
 671             sb.Append(m_Item3);
 672             sb.Append(", ");
 673             sb.Append(m_Item4);
 674             sb.Append(", ");
 675             sb.Append(m_Item5);
 676             sb.Append(')');
 677             return sb.ToString();
 678         }
 679
 680         /// <summary>
 681         /// The number of positions in this data structure.
 682         /// </summary>
 683         int ITuple.Length => 5;
 684
 685         /// <summary>
 686         /// Get the element at position <param name="index"/>.
 687         /// </summary>
 688         object? ITuple.this[int index]
 689         {
 690             get
 691             {
 692                 switch (index)
 693                 {
 694                     case 0:
 695                         return Item1;
 696                     case 1:
 697                         return Item2;
 698                     case 2:
 699                         return Item3;
 700                     case 3:
 701                         return Item4;
 702                     case 4:
 703                         return Item5;
 704                     default:
 705                         throw new IndexOutOfRangeException();
 706                 }
 707             }
 708         }
 709     }
 710
 711     [Serializable]
 712     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 713     public class Tuple<T1, T2, T3, T4, T5, T6> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 714     {
 715         private readonly T1 m_Item1; // Do not rename (binary serialization)
 716         private readonly T2 m_Item2; // Do not rename (binary serialization)
 717         private readonly T3 m_Item3; // Do not rename (binary serialization)
 718         private readonly T4 m_Item4; // Do not rename (binary serialization)
 719         private readonly T5 m_Item5; // Do not rename (binary serialization)
 720         private readonly T6 m_Item6; // Do not rename (binary serialization)
 721
 722         public T1 Item1 { get { return m_Item1; } }
 723         public T2 Item2 { get { return m_Item2; } }
 724         public T3 Item3 { get { return m_Item3; } }
 725         public T4 Item4 { get { return m_Item4; } }
 726         public T5 Item5 { get { return m_Item5; } }
 727         public T6 Item6 { get { return m_Item6; } }
 728
 729         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
 730         {
 731             m_Item1 = item1;
 732             m_Item2 = item2;
 733             m_Item3 = item3;
 734             m_Item4 = item4;
 735             m_Item5 = item5;
 736             m_Item6 = item6;
 737         }
 738
 739         public override bool Equals(object? obj)
 740         {
 741             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 742         }
 743
 744         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 745         {
 746             if (other == null) return false;
 747
 748             if (!(other is Tuple<T1, T2, T3, T4, T5, T6> objTuple))
 749             {
 750                 return false;
 751             }
 752
 753             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);
 754         }
 755
 756         int IComparable.CompareTo(object? obj)
 757         {
 758             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 759         }
 760
 761         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 762         {
 763             if (other == null) return 1;
 764
 765             if (!(other is Tuple<T1, T2, T3, T4, T5, T6> objTuple))
 766             {
 767                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 768             }
 769
 770             int c = 0;
 771
 772             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 773
 774             if (c != 0) return c;
 775
 776             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 777
 778             if (c != 0) return c;
 779
 780             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 781
 782             if (c != 0) return c;
 783
 784             c = comparer.Compare(m_Item4, objTuple.m_Item4);
 785
 786             if (c != 0) return c;
 787
 788             c = comparer.Compare(m_Item5, objTuple.m_Item5);
 789
 790             if (c != 0) return c;
 791
 792             return comparer.Compare(m_Item6, objTuple.m_Item6);
 793         }
 794
 795         public override int GetHashCode()
 796         {
 797             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 798         }
 799
 800         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 801         {
 802             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!));
 803         }
 804
 805         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 806         {
 807             return ((IStructuralEquatable)this).GetHashCode(comparer);
 808         }
 809         public override string ToString()
 810         {
 811             StringBuilder sb = new StringBuilder();
 812             sb.Append('(');
 813             return ((ITupleInternal)this).ToString(sb);
 814         }
 815
 816         string ITupleInternal.ToString(StringBuilder sb)
 817         {
 818             sb.Append(m_Item1);
 819             sb.Append(", ");
 820             sb.Append(m_Item2);
 821             sb.Append(", ");
 822             sb.Append(m_Item3);
 823             sb.Append(", ");
 824             sb.Append(m_Item4);
 825             sb.Append(", ");
 826             sb.Append(m_Item5);
 827             sb.Append(", ");
 828             sb.Append(m_Item6);
 829             sb.Append(')');
 830             return sb.ToString();
 831         }
 832
 833         /// <summary>
 834         /// The number of positions in this data structure.
 835         /// </summary>
 836         int ITuple.Length => 6;
 837
 838         /// <summary>
 839         /// Get the element at position <param name="index"/>.
 840         /// </summary>
 841         object? ITuple.this[int index]
 842         {
 843             get
 844             {
 845                 switch (index)
 846                 {
 847                     case 0:
 848                         return Item1;
 849                     case 1:
 850                         return Item2;
 851                     case 2:
 852                         return Item3;
 853                     case 3:
 854                         return Item4;
 855                     case 4:
 856                         return Item5;
 857                     case 5:
 858                         return Item6;
 859                     default:
 860                         throw new IndexOutOfRangeException();
 861                 }
 862             }
 863         }
 864     }
 865
 866     [Serializable]
 867     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
 868     public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
 869     {
 870         private readonly T1 m_Item1; // Do not rename (binary serialization)
 871         private readonly T2 m_Item2; // Do not rename (binary serialization)
 872         private readonly T3 m_Item3; // Do not rename (binary serialization)
 873         private readonly T4 m_Item4; // Do not rename (binary serialization)
 874         private readonly T5 m_Item5; // Do not rename (binary serialization)
 875         private readonly T6 m_Item6; // Do not rename (binary serialization)
 876         private readonly T7 m_Item7; // Do not rename (binary serialization)
 877
 878         public T1 Item1 { get { return m_Item1; } }
 879         public T2 Item2 { get { return m_Item2; } }
 880         public T3 Item3 { get { return m_Item3; } }
 881         public T4 Item4 { get { return m_Item4; } }
 882         public T5 Item5 { get { return m_Item5; } }
 883         public T6 Item6 { get { return m_Item6; } }
 884         public T7 Item7 { get { return m_Item7; } }
 885
 886         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
 887         {
 888             m_Item1 = item1;
 889             m_Item2 = item2;
 890             m_Item3 = item3;
 891             m_Item4 = item4;
 892             m_Item5 = item5;
 893             m_Item6 = item6;
 894             m_Item7 = item7;
 895         }
 896
 897         public override bool Equals(object? obj)
 898         {
 899             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
 900         }
 901
 902         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
 903         {
 904             if (other == null) return false;
 905
 906             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7> objTuple))
 907             {
 908                 return false;
 909             }
 910
 911             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);
 912         }
 913
 914         int IComparable.CompareTo(object? obj)
 915         {
 916             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
 917         }
 918
 919         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
 920         {
 921             if (other == null) return 1;
 922
 923             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7> objTuple))
 924             {
 925                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
 926             }
 927
 928             int c = 0;
 929
 930             c = comparer.Compare(m_Item1, objTuple.m_Item1);
 931
 932             if (c != 0) return c;
 933
 934             c = comparer.Compare(m_Item2, objTuple.m_Item2);
 935
 936             if (c != 0) return c;
 937
 938             c = comparer.Compare(m_Item3, objTuple.m_Item3);
 939
 940             if (c != 0) return c;
 941
 942             c = comparer.Compare(m_Item4, objTuple.m_Item4);
 943
 944             if (c != 0) return c;
 945
 946             c = comparer.Compare(m_Item5, objTuple.m_Item5);
 947
 948             if (c != 0) return c;
 949
 950             c = comparer.Compare(m_Item6, objTuple.m_Item6);
 951
 952             if (c != 0) return c;
 953
 954             return comparer.Compare(m_Item7, objTuple.m_Item7);
 955         }
 956
 957         public override int GetHashCode()
 958         {
 959             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
 960         }
 961
 962         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
 963         {
 964             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!));
 965         }
 966
 967         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
 968         {
 969             return ((IStructuralEquatable)this).GetHashCode(comparer);
 970         }
 971         public override string ToString()
 972         {
 973             StringBuilder sb = new StringBuilder();
 974             sb.Append('(');
 975             return ((ITupleInternal)this).ToString(sb);
 976         }
 977
 978         string ITupleInternal.ToString(StringBuilder sb)
 979         {
 980             sb.Append(m_Item1);
 981             sb.Append(", ");
 982             sb.Append(m_Item2);
 983             sb.Append(", ");
 984             sb.Append(m_Item3);
 985             sb.Append(", ");
 986             sb.Append(m_Item4);
 987             sb.Append(", ");
 988             sb.Append(m_Item5);
 989             sb.Append(", ");
 990             sb.Append(m_Item6);
 991             sb.Append(", ");
 992             sb.Append(m_Item7);
 993             sb.Append(')');
 994             return sb.ToString();
 995         }
 996
 997         /// <summary>
 998         /// The number of positions in this data structure.
 999         /// </summary>
1000         int ITuple.Length => 7;
1001
1002         /// <summary>
1003         /// Get the element at position <param name="index"/>.
1004         /// </summary>
1005         object? ITuple.this[int index]
1006         {
1007             get
1008             {
1009                 switch (index)
1010                 {
1011                     case 0:
1012                         return Item1;
1013                     case 1:
1014                         return Item2;
1015                     case 2:
1016                         return Item3;
1017                     case 3:
1018                         return Item4;
1019                     case 4:
1020                         return Item5;
1021                     case 5:
1022                         return Item6;
1023                     case 6:
1024                         return Item7;
1025                     default:
1026                         throw new IndexOutOfRangeException();
1027                 }
1028             }
1029         }
1030     }
1031
1032     [Serializable]
1033     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
1034     public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple where TRest : object
1035     {
1036         private readonly T1 m_Item1; // Do not rename (binary serialization)
1037         private readonly T2 m_Item2; // Do not rename (binary serialization)
1038         private readonly T3 m_Item3; // Do not rename (binary serialization)
1039         private readonly T4 m_Item4; // Do not rename (binary serialization)
1040         private readonly T5 m_Item5; // Do not rename (binary serialization)
1041         private readonly T6 m_Item6; // Do not rename (binary serialization)
1042         private readonly T7 m_Item7; // Do not rename (binary serialization)
1043         private readonly TRest m_Rest; // Do not rename (binary serialization)
1044
1045         public T1 Item1 { get { return m_Item1; } }
1046         public T2 Item2 { get { return m_Item2; } }
1047         public T3 Item3 { get { return m_Item3; } }
1048         public T4 Item4 { get { return m_Item4; } }
1049         public T5 Item5 { get { return m_Item5; } }
1050         public T6 Item6 { get { return m_Item6; } }
1051         public T7 Item7 { get { return m_Item7; } }
1052         public TRest Rest { get { return m_Rest; } }
1053
1054         public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
1055         {
1056             if (!(rest is ITupleInternal))
1057             {
1058                 throw new ArgumentException(SR.ArgumentException_TupleLastArgumentNotATuple);
1059             }
1060
1061             m_Item1 = item1;
1062             m_Item2 = item2;
1063             m_Item3 = item3;
1064             m_Item4 = item4;
1065             m_Item5 = item5;
1066             m_Item6 = item6;
1067             m_Item7 = item7;
1068             m_Rest = rest;
1069         }
1070
1071         public override bool Equals(object? obj)
1072         {
1073             return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
1074         }
1075
1076         bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
1077         {
1078             if (other == null) return false;
1079
1080             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> objTuple))
1081             {
1082                 return false;
1083             }
1084
1085             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);
1086         }
1087
1088         int IComparable.CompareTo(object? obj)
1089         {
1090             return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
1091         }
1092
1093         int IStructuralComparable.CompareTo(object? other, IComparer comparer)
1094         {
1095             if (other == null) return 1;
1096
1097             if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> objTuple))
1098             {
1099                 throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), nameof(other));
1100             }
1101
1102             int c = 0;
1103
1104             c = comparer.Compare(m_Item1, objTuple.m_Item1);
1105
1106             if (c != 0) return c;
1107
1108             c = comparer.Compare(m_Item2, objTuple.m_Item2);
1109
1110             if (c != 0) return c;
1111
1112             c = comparer.Compare(m_Item3, objTuple.m_Item3);
1113
1114             if (c != 0) return c;
1115
1116             c = comparer.Compare(m_Item4, objTuple.m_Item4);
1117
1118             if (c != 0) return c;
1119
1120             c = comparer.Compare(m_Item5, objTuple.m_Item5);
1121
1122             if (c != 0) return c;
1123
1124             c = comparer.Compare(m_Item6, objTuple.m_Item6);
1125
1126             if (c != 0) return c;
1127
1128             c = comparer.Compare(m_Item7, objTuple.m_Item7);
1129
1130             if (c != 0) return c;
1131
1132             return comparer.Compare(m_Rest, objTuple.m_Rest);
1133         }
1134
1135         public override int GetHashCode()
1136         {
1137             return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
1138         }
1139
1140         int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
1141         {
1142             // We want to have a limited hash in this case.  We'll use the last 8 elements of the tuple
1143             ITupleInternal t = (ITupleInternal)m_Rest;
1144             if (t.Length >= 8) { return t.GetHashCode(comparer); }
1145
1146             // In this case, the rest memeber has less than 8 elements so we need to combine some our elements with the elements in rest
1147             int k = 8 - t.Length;
1148             switch (k)
1149             {
1150                 case 1:
1151                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1152                 case 2:
1153                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1154                 case 3:
1155                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1156                 case 4:
1157                     return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item4!), comparer.GetHashCode(m_Item5!), comparer.GetHashCode(m_Item6!), comparer.GetHashCode(m_Item7!), t.GetHashCode(comparer));
1158                 case 5:
1159                     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));
1160                 case 6:
1161                     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));
1162                 case 7:
1163                     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));
1164             }
1165             Debug.Fail("Missed all cases for computing Tuple hash code");
1166             return -1;
1167         }
1168
1169         int ITupleInternal.GetHashCode(IEqualityComparer comparer)
1170         {
1171             return ((IStructuralEquatable)this).GetHashCode(comparer);
1172         }
1173         public override string ToString()
1174         {
1175             StringBuilder sb = new StringBuilder();
1176             sb.Append('(');
1177             return ((ITupleInternal)this).ToString(sb);
1178         }
1179
1180         string ITupleInternal.ToString(StringBuilder sb)
1181         {
1182             sb.Append(m_Item1);
1183             sb.Append(", ");
1184             sb.Append(m_Item2);
1185             sb.Append(", ");
1186             sb.Append(m_Item3);
1187             sb.Append(", ");
1188             sb.Append(m_Item4);
1189             sb.Append(", ");
1190             sb.Append(m_Item5);
1191             sb.Append(", ");
1192             sb.Append(m_Item6);
1193             sb.Append(", ");
1194             sb.Append(m_Item7);
1195             sb.Append(", ");
1196             return ((ITupleInternal)m_Rest).ToString(sb);
1197         }
1198
1199         /// <summary>
1200         /// The number of positions in this data structure.
1201         /// </summary>
1202         int ITuple.Length
1203         {
1204             get
1205             {
1206                 return 7 + ((ITupleInternal)Rest).Length;
1207             }
1208         }
1209
1210         /// <summary>
1211         /// Get the element at position <param name="index"/>.
1212         /// </summary>
1213         object? ITuple.this[int index]
1214         {
1215             get
1216             {
1217                 switch (index)
1218                 {
1219                     case 0:
1220                         return Item1;
1221                     case 1:
1222                         return Item2;
1223                     case 2:
1224                         return Item3;
1225                     case 3:
1226                         return Item4;
1227                     case 4:
1228                         return Item5;
1229                     case 5:
1230                         return Item6;
1231                     case 6:
1232                         return Item7;
1233                 }
1234
1235                 return ((ITupleInternal)Rest)[index - 7];
1236             }
1237         }
1238     }
1239 }