mcs/class/referencesource/mscorlib/system/tuple.cs

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