mcs/class/Mono.C5/C5/Builtin.cs

   1 /*\r
   2  Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
   3  Permission is hereby granted, free of charge, to any person obtaining a copy\r
   4  of this software and associated documentation files (the "Software"), to deal\r
   5  in the Software without restriction, including without limitation the rights\r
   6  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   7  copies of the Software, and to permit persons to whom the Software is\r
   8  furnished to do so, subject to the following conditions:\r
   9  \r
  10  The above copyright notice and this permission notice shall be included in\r
  11  all copies or substantial portions of the Software.\r
  12  \r
  13  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  14  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  15  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  16  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  17  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  18  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  19  SOFTWARE.\r
  20 */\r
  21 using System;\r
  22 using System.Diagnostics;\r
  23 using SCG = System.Collections.Generic;\r
  24 namespace C5\r
  25 {\r
  26   #region char comparer and equality comparer\r
  27   class CharComparer : SCG.IComparer<char>\r
  28   {\r
  29     public int Compare(char item1, char item2) { \r
  30       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0; \r
  31     }\r
  32   }\r
  33 \r
  34   /// <summary>\r
  35   /// An equality comparer for type char, also known as System.Char.\r
  36   /// </summary>\r
  37   public class CharEqualityComparer : SCG.IEqualityComparer<char>\r
  38   {\r
  39     static CharEqualityComparer cached = new CharEqualityComparer();\r
  40     CharEqualityComparer() { }\r
  41     /// <summary>\r
  42     /// \r
  43     /// </summary>\r
  44     /// <value></value>\r
  45     public static CharEqualityComparer Default { get { return cached ?? (cached = new CharEqualityComparer()); } }\r
  46 \r
  47     /// <summary>\r
  48     /// Get the hash code of this char\r
  49     /// </summary>\r
  50     /// <param name="item">The char</param>\r
  51     /// <returns>The same</returns>\r
  52     public int GetHashCode(char item) { return item.GetHashCode(); }\r
  53 \r
  54 \r
  55     /// <summary>\r
  56     /// Check if two chars are equal\r
  57     /// </summary>\r
  58     /// <param name="item1">first char</param>\r
  59     /// <param name="item2">second char</param>\r
  60     /// <returns>True if equal</returns>\r
  61     public bool Equals(char item1, char item2) { return item1 == item2; }\r
  62   }\r
  63   #endregion\r
  64   \r
  65   #region sbyte comparer and equality comparer\r
  66   [Serializable]\r
  67   class SByteComparer : SCG.IComparer<sbyte>\r
  68   {\r
  69     [Tested]\r
  70     public int Compare(sbyte item1, sbyte item2) { \r
  71       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0; \r
  72     }\r
  73   }\r
  74 \r
  75   /// <summary>\r
  76   /// An equality comparer for type sbyte, also known as System.SByte. \r
  77   /// <para>This class is a singleton and the instance can be accessed\r
  78   /// via the static <see cref="P:C5.SByteEqualityComparer.Default"/> property</para>\r
  79   /// </summary>\r
  80   [Serializable]\r
  81   public class SByteEqualityComparer : SCG.IEqualityComparer<sbyte>\r
  82   {\r
  83     static SByteEqualityComparer cached;\r
  84     SByteEqualityComparer() { }\r
  85 \r
  86     /// <summary>\r
  87     /// \r
  88     /// </summary>\r
  89     /// <value></value>\r
  90     [Tested]\r
  91     public static SByteEqualityComparer Default { get { return cached ?? (cached = new SByteEqualityComparer()); } }\r
  92     /// <summary>\r
  93     /// Get the hash code of this sbyte, that is, itself\r
  94     /// </summary>\r
  95     /// <param name="item">The sbyte</param>\r
  96     /// <returns>The same</returns>\r
  97     [Tested]\r
  98     public int GetHashCode(sbyte item) { return item.GetHashCode(); }\r
  99 \r
 100 \r
 101     /// <summary>\r
 102     /// Determine whether two sbytes are equal\r
 103     /// </summary>\r
 104     /// <param name="item1">first sbyte</param>\r
 105     /// <param name="item2">second sbyte</param>\r
 106     /// <returns>True if equal</returns>\r
 107     [Tested]\r
 108     public bool Equals(sbyte item1, sbyte item2) { return item1 == item2; }\r
 109   }\r
 110 \r
 111   #endregion\r
 112 \r
 113   #region byte comparer and equality comparer\r
 114   class ByteComparer : SCG.IComparer<byte>\r
 115   {\r
 116     public int Compare(byte item1, byte item2) { \r
 117       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0; \r
 118     }\r
 119   }\r
 120 \r
 121   /// <summary>\r
 122   /// An equality comparer for type byte, also known as System.Byte.\r
 123   /// <para>This class is a singleton and the instance can be accessed\r
 124   /// via the <see cref="P:C5.ByteEqualityComparer.Default"/> property</para>\r
 125   /// </summary>\r
 126   public class ByteEqualityComparer : SCG.IEqualityComparer<byte>\r
 127   {\r
 128     static ByteEqualityComparer cached = new ByteEqualityComparer();\r
 129     ByteEqualityComparer() { }\r
 130     /// <summary>\r
 131     /// \r
 132     /// </summary>\r
 133     /// <value></value>\r
 134     public static ByteEqualityComparer Default { get { return cached ?? (cached = new ByteEqualityComparer()); } }\r
 135     /// <summary>\r
 136     /// Get the hash code of this byte, i.e. itself\r
 137     /// </summary>\r
 138     /// <param name="item">The byte</param>\r
 139     /// <returns>The same</returns>\r
 140     public int GetHashCode(byte item) { return item.GetHashCode(); }\r
 141 \r
 142     /// <summary>\r
 143     /// Check if two bytes are equal\r
 144     /// </summary>\r
 145     /// <param name="item1">first byte</param>\r
 146     /// <param name="item2">second byte</param>\r
 147     /// <returns>True if equal</returns>\r
 148     public bool Equals(byte item1, byte item2) { return item1 == item2; }\r
 149   }\r
 150   #endregion\r
 151 \r
 152   #region short comparer and equality comparer\r
 153   [Serializable]\r
 154   class ShortComparer : SCG.IComparer<short>\r
 155   {\r
 156     [Tested]\r
 157     public int Compare(short item1, short item2) { \r
 158       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0; \r
 159     }\r
 160   }\r
 161 \r
 162   /// <summary>\r
 163   /// An equality comparer for type short, also known as System.Int16. \r
 164   /// <para>This class is a singleton and the instance can be accessed\r
 165   /// via the static <see cref="P:C5.ShortEqualityComparer.Default"/> property</para>\r
 166   /// </summary>\r
 167   [Serializable]\r
 168   public class ShortEqualityComparer : SCG.IEqualityComparer<short>\r
 169   {\r
 170     static ShortEqualityComparer cached;\r
 171     ShortEqualityComparer() { }\r
 172 \r
 173     /// <summary>\r
 174     /// \r
 175     /// </summary>\r
 176     /// <value></value>\r
 177     [Tested]\r
 178     public static ShortEqualityComparer Default { get { return cached ?? (cached = new ShortEqualityComparer()); } }\r
 179     /// <summary>\r
 180     /// Get the hash code of this short, that is, itself\r
 181     /// </summary>\r
 182     /// <param name="item">The short</param>\r
 183     /// <returns>The same</returns>\r
 184     [Tested]\r
 185     public int GetHashCode(short item) { return item.GetHashCode(); }\r
 186 \r
 187 \r
 188     /// <summary>\r
 189     /// Determine whether two shorts are equal\r
 190     /// </summary>\r
 191     /// <param name="item1">first short</param>\r
 192     /// <param name="item2">second short</param>\r
 193     /// <returns>True if equal</returns>\r
 194     [Tested]\r
 195     public bool Equals(short item1, short item2) { return item1 == item2; }\r
 196   }\r
 197 \r
 198   #endregion\r
 199 \r
 200   #region ushort comparer and equality comparer\r
 201   [Serializable]\r
 202   class UShortComparer : SCG.IComparer<ushort>\r
 203   {\r
 204     [Tested]\r
 205     public int Compare(ushort item1, ushort item2)\r
 206     {\r
 207       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0;\r
 208     }\r
 209   }\r
 210 \r
 211   /// <summary>\r
 212   /// An equality comparer for type ushort, also known as System.UInt16. \r
 213   /// <para>This class is a singleton and the instance can be accessed\r
 214   /// via the static <see cref="P:C5.UShortEqualityComparer.Default"/> property</para>\r
 215   /// </summary>\r
 216   [Serializable]\r
 217   public class UShortEqualityComparer : SCG.IEqualityComparer<ushort>\r
 218   {\r
 219     static UShortEqualityComparer cached;\r
 220     UShortEqualityComparer() { }\r
 221 \r
 222     /// <summary>\r
 223     /// \r
 224     /// </summary>\r
 225     /// <value></value>\r
 226     [Tested]\r
 227     public static UShortEqualityComparer Default { get { return cached ?? (cached = new UShortEqualityComparer()); } }\r
 228     /// <summary>\r
 229     /// Get the hash code of this ushort, that is, itself\r
 230     /// </summary>\r
 231     /// <param name="item">The ushort</param>\r
 232     /// <returns>The same</returns>\r
 233     [Tested]\r
 234     public int GetHashCode(ushort item) { return item.GetHashCode(); }\r
 235 \r
 236 \r
 237     /// <summary>\r
 238     /// Determine whether two ushorts are equal\r
 239     /// </summary>\r
 240     /// <param name="item1">first ushort</param>\r
 241     /// <param name="item2">second ushort</param>\r
 242     /// <returns>True if equal</returns>\r
 243     [Tested]\r
 244     public bool Equals(ushort item1, ushort item2) { return item1 == item2; }\r
 245   }\r
 246 \r
 247   #endregion\r
 248 \r
 249   #region int comparer and equality comparer\r
 250   [Serializable]\r
 251   class IntComparer : SCG.IComparer<int>\r
 252   {\r
 253     [Tested]\r
 254     public int Compare(int item1, int item2) { \r
 255       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0; \r
 256     }\r
 257   }\r
 258 \r
 259   /// <summary>\r
 260   /// An equality comparer for type int, also known as System.Int32. \r
 261   /// <para>This class is a singleton and the instance can be accessed\r
 262   /// via the static <see cref="P:C5.IntEqualityComparer.Default"/> property</para>\r
 263   /// </summary>\r
 264   [Serializable]\r
 265   public class IntEqualityComparer : SCG.IEqualityComparer<int>\r
 266   {\r
 267     static IntEqualityComparer cached;\r
 268     IntEqualityComparer() { }\r
 269     /// <summary>\r
 270     /// \r
 271     /// </summary>\r
 272     /// <value></value>\r
 273     [Tested]\r
 274     public static IntEqualityComparer Default { get { return cached ?? (cached = new IntEqualityComparer()); } }\r
 275     /// <summary>\r
 276     /// Get the hash code of this integer, that is, itself\r
 277     /// </summary>\r
 278     /// <param name="item">The integer</param>\r
 279     /// <returns>The same</returns>\r
 280     [Tested]\r
 281     public int GetHashCode(int item) { return item; }\r
 282 \r
 283 \r
 284     /// <summary>\r
 285     /// Determine whether two integers are equal\r
 286     /// </summary>\r
 287     /// <param name="item1">first integer</param>\r
 288     /// <param name="item2">second integer</param>\r
 289     /// <returns>True if equal</returns>\r
 290     [Tested]\r
 291     public bool Equals(int item1, int item2) { return item1 == item2; }\r
 292   }\r
 293 \r
 294   #endregion\r
 295 \r
 296   #region uint comparer and equality comparer\r
 297   [Serializable]\r
 298   class UIntComparer : SCG.IComparer<uint>\r
 299   {\r
 300     [Tested]\r
 301     public int Compare(uint item1, uint item2)\r
 302     {\r
 303       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0;\r
 304     }\r
 305   }\r
 306 \r
 307   /// <summary>\r
 308   /// An equality comparer for type uint, also known as System.UInt32. \r
 309   /// <para>This class is a singleton and the instance can be accessed\r
 310   /// via the static <see cref="P:C5.UIntEqualityComparer.Default"/> property</para>\r
 311   /// </summary>\r
 312   [Serializable]\r
 313   public class UIntEqualityComparer : SCG.IEqualityComparer<uint>\r
 314   {\r
 315     static UIntEqualityComparer cached;\r
 316     UIntEqualityComparer() { }\r
 317     /// <summary>\r
 318     /// \r
 319     /// </summary>\r
 320     /// <value></value>\r
 321     [Tested]\r
 322     public static UIntEqualityComparer Default { get { return cached ?? (cached = new UIntEqualityComparer()); } }\r
 323     /// <summary>\r
 324     /// Get the hash code of this unsigned integer\r
 325     /// </summary>\r
 326     /// <param name="item">The integer</param>\r
 327     /// <returns>The same bit pattern as a signed integer</returns>\r
 328     [Tested]\r
 329     public int GetHashCode(uint item) { return item.GetHashCode(); }\r
 330 \r
 331 \r
 332     /// <summary>\r
 333     /// Determine whether two unsigned integers are equal\r
 334     /// </summary>\r
 335     /// <param name="item1">first unsigned integer</param>\r
 336     /// <param name="item2">second unsigned integer</param>\r
 337     /// <returns>True if equal</returns>\r
 338     [Tested]\r
 339     public bool Equals(uint item1, uint item2) { return item1 == item2; }\r
 340   }\r
 341 \r
 342   #endregion\r
 343 \r
 344   #region long comparer and equality comparer\r
 345   [Serializable]\r
 346   class LongComparer : SCG.IComparer<long>\r
 347   {\r
 348     [Tested]\r
 349     public int Compare(long item1, long item2)\r
 350     {\r
 351       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0;\r
 352     }\r
 353   }\r
 354 \r
 355   /// <summary>\r
 356   /// An equality comparer for type long, also known as System.Int64. \r
 357   /// <para>This class is a singleton and the instance can be accessed\r
 358   /// via the static <see cref="P:C5.LongEqualityComparer.Default"/> property</para>\r
 359   /// </summary>\r
 360   [Serializable]\r
 361   public class LongEqualityComparer : SCG.IEqualityComparer<long>\r
 362   {\r
 363     static LongEqualityComparer cached;\r
 364     LongEqualityComparer() { }\r
 365     /// <summary>\r
 366     /// \r
 367     /// </summary>\r
 368     /// <value></value>\r
 369     [Tested]\r
 370     public static LongEqualityComparer Default { get { return cached ?? (cached = new LongEqualityComparer()); } }\r
 371     /// <summary>\r
 372     /// Get the hash code of this long integer\r
 373     /// </summary>\r
 374     /// <param name="item">The long integer</param>\r
 375     /// <returns>The hash code</returns>\r
 376     [Tested]\r
 377     public int GetHashCode(long item) { return item.GetHashCode(); }\r
 378 \r
 379 \r
 380     /// <summary>\r
 381     /// Determine whether two long integers are equal\r
 382     /// </summary>\r
 383     /// <param name="item1">first long integer</param>\r
 384     /// <param name="item2">second long integer</param>\r
 385     /// <returns>True if equal</returns>\r
 386     [Tested]\r
 387     public bool Equals(long item1, long item2) { return item1 == item2; }\r
 388   }\r
 389 \r
 390   #endregion\r
 391 \r
 392   #region ulong comparer and equality comparer\r
 393   [Serializable]\r
 394   class ULongComparer : SCG.IComparer<ulong>\r
 395   {\r
 396     [Tested]\r
 397     public int Compare(ulong item1, ulong item2)\r
 398     {\r
 399       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0;\r
 400     }\r
 401   }\r
 402 \r
 403   /// <summary>\r
 404   /// An equality comparer for type uint, also known as System.UInt64. \r
 405   /// <para>This class is a singleton and the instance can be accessed\r
 406   /// via the static <see cref="P:C5.ULongEqualityComparer.Default"/> property</para>\r
 407   /// </summary>\r
 408   [Serializable]\r
 409   public class ULongEqualityComparer : SCG.IEqualityComparer<ulong>\r
 410   {\r
 411     static ULongEqualityComparer cached;\r
 412     ULongEqualityComparer() { }\r
 413     /// <summary>\r
 414     /// \r
 415     /// </summary>\r
 416     /// <value></value>\r
 417     [Tested]\r
 418     public static ULongEqualityComparer Default { get { return cached ?? (cached = new ULongEqualityComparer()); } }\r
 419     /// <summary>\r
 420     /// Get the hash code of this unsigned long integer\r
 421     /// </summary>\r
 422     /// <param name="item">The unsigned long integer</param>\r
 423     /// <returns>The hash code</returns>\r
 424     [Tested]\r
 425     public int GetHashCode(ulong item) { return item.GetHashCode(); }\r
 426 \r
 427 \r
 428     /// <summary>\r
 429     /// Determine whether two unsigned long integers are equal\r
 430     /// </summary>\r
 431     /// <param name="item1">first unsigned long integer</param>\r
 432     /// <param name="item2">second unsigned long integer</param>\r
 433     /// <returns>True if equal</returns>\r
 434     [Tested]\r
 435     public bool Equals(ulong item1, ulong item2) { return item1 == item2; }\r
 436   }\r
 437 \r
 438   #endregion\r
 439 \r
 440   #region float comparer and equality comparer\r
 441   class FloatComparer : SCG.IComparer<float>\r
 442   {\r
 443     public int Compare(float item1, float item2)\r
 444     {\r
 445       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0;\r
 446     }\r
 447   }\r
 448 \r
 449   /// <summary>\r
 450   /// An equality comparer for type float, also known as System.Single. \r
 451   /// <para>This class is a singleton and the instance can be accessed\r
 452   /// via the static <see cref="P:C5.FloatEqualityComparer.Default"/> property</para>\r
 453   /// </summary>\r
 454   public class FloatEqualityComparer : SCG.IEqualityComparer<float>\r
 455   {\r
 456     static FloatEqualityComparer cached;\r
 457     FloatEqualityComparer() { }\r
 458     /// <summary>\r
 459     /// \r
 460     /// </summary>\r
 461     /// <value></value>\r
 462     [Tested]\r
 463     public static FloatEqualityComparer Default { get { return cached ?? (cached = new FloatEqualityComparer()); } }\r
 464     /// <summary>\r
 465     /// Get the hash code of this float\r
 466     /// </summary>\r
 467     /// <param name="item">The float</param>\r
 468     /// <returns>The same</returns>\r
 469     [Tested]\r
 470     public int GetHashCode(float item) { return item.GetHashCode(); }\r
 471 \r
 472 \r
 473     /// <summary>\r
 474     /// Check if two floats are equal\r
 475     /// </summary>\r
 476     /// <param name="item1">first float</param>\r
 477     /// <param name="item2">second float</param>\r
 478     /// <returns>True if equal</returns>\r
 479     [Tested]\r
 480     public bool Equals(float item1, float item2) { return item1 == item2; }\r
 481   }\r
 482   #endregion\r
 483 \r
 484   #region double comparer and equality comparer\r
 485   class DoubleComparer : SCG.IComparer<double>\r
 486   {\r
 487     public int Compare(double item1, double item2) { \r
 488       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0; \r
 489     }\r
 490   }\r
 491 \r
 492   /// <summary>\r
 493   /// An equality comparer for type double, also known as System.Double.\r
 494   /// <para>This class is a singleton and the instance can be accessed\r
 495   /// via the static <see cref="P:C5.DoubleEqualityComparer.Default"/> property</para>\r
 496   /// </summary>\r
 497   public class DoubleEqualityComparer : SCG.IEqualityComparer<double>\r
 498   {\r
 499     static DoubleEqualityComparer cached;\r
 500     DoubleEqualityComparer() { }\r
 501     /// <summary>\r
 502     /// \r
 503     /// </summary>\r
 504     /// <value></value>\r
 505     [Tested]\r
 506     public static DoubleEqualityComparer Default { get { return cached ?? (cached = new DoubleEqualityComparer()); } }\r
 507     /// <summary>\r
 508     /// Get the hash code of this double\r
 509     /// </summary>\r
 510     /// <param name="item">The double</param>\r
 511     /// <returns>The same</returns>\r
 512     [Tested]\r
 513     public int GetHashCode(double item) { return item.GetHashCode(); }\r
 514 \r
 515 \r
 516     /// <summary>\r
 517     /// Check if two doubles are equal\r
 518     /// </summary>\r
 519     /// <param name="item1">first double</param>\r
 520     /// <param name="item2">second double</param>\r
 521     /// <returns>True if equal</returns>\r
 522     [Tested]\r
 523     public bool Equals(double item1, double item2) { return item1 == item2; }\r
 524   }\r
 525   #endregion\r
 526 \r
 527   #region decimal comparer and equality comparer\r
 528   [Serializable]\r
 529   class DecimalComparer : SCG.IComparer<decimal>\r
 530   {\r
 531     [Tested]\r
 532     public int Compare(decimal item1, decimal item2)\r
 533     {\r
 534       return item1 > item2 ? 1 : item1 < item2 ? -1 : 0;\r
 535     }\r
 536   }\r
 537 \r
 538   /// <summary>\r
 539   /// An equality comparer for type decimal, also known as System.Decimal. \r
 540   /// <para>This class is a singleton and the instance can be accessed\r
 541   /// via the static <see cref="P:C5.DecimalEqualityComparer.Default"/> property</para>\r
 542   /// </summary>\r
 543   [Serializable]\r
 544   public class DecimalEqualityComparer : SCG.IEqualityComparer<decimal>\r
 545   {\r
 546     static DecimalEqualityComparer cached;\r
 547     DecimalEqualityComparer() { }\r
 548     /// <summary>\r
 549     /// \r
 550     /// </summary>\r
 551     /// <value></value>\r
 552     [Tested]\r
 553     public static DecimalEqualityComparer Default { get { return cached ?? (cached = new DecimalEqualityComparer()); } }\r
 554     /// <summary>\r
 555     /// Get the hash code of this decimal.\r
 556     /// </summary>\r
 557     /// <param name="item">The decimal</param>\r
 558     /// <returns>The hash code</returns>\r
 559     [Tested]\r
 560     public int GetHashCode(decimal item) { return item.GetHashCode(); }\r
 561 \r
 562 \r
 563     /// <summary>\r
 564     /// Determine whether two decimals are equal\r
 565     /// </summary>\r
 566     /// <param name="item1">first decimal</param>\r
 567     /// <param name="item2">second decimal</param>\r
 568     /// <returns>True if equal</returns>\r
 569     [Tested]\r
 570     public bool Equals(decimal item1, decimal item2) { return item1 == item2; }\r
 571   }\r
 572 \r
 573   #endregion\r
 574 }