mcs/class/corlib/System/ValueType.cs

   1 //
   2 // System.ValueType.cs
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //
   8 // (C) Ximian, Inc.  http://www.ximian.com
   9 // (C) 2003 Novell, Inc.  http://www.novell.com
  10 //
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 //
  36 // Copyright (c) Microsoft. All rights reserved.
  37 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
  38 //
  39 // Files:
  40 //  - mscorlib/system/valuetype.cs
  41 //
  42
  43 using System.Reflection;
  44 using System.Runtime.CompilerServices;
  45 using System.Runtime.InteropServices;
  46 using System.Threading;
  47
  48 namespace System
  49 {
  50         [Serializable]
  51         [ComVisible (true)]
  52         public abstract class ValueType
  53         {
  54                 /*
  55                  * Caution: Fields added to ValueType can mess with sub class layouts.
  56                  * Causing bugs that appear completely unrelated as #30060
  57                  */
  58                 private static class Internal
  59                 {
  60                         public static int hash_code_of_ptr_seed = 0;
  61                 }
  62
  63                 protected ValueType ()
  64                 {
  65                 }
  66
  67                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  68                 private extern static bool InternalEquals (object o1, object o2, out object[] fields);
  69
  70                 // This is also used by RuntimeHelpers
  71                 internal static bool DefaultEquals (object o1, object o2)
  72                 {
  73                         if (o1 == null && o2 == null)
  74                                 return true;
  75                         if (o1 == null || o2 == null)
  76                                 return false;
  77
  78                         RuntimeType o1_type = (RuntimeType) o1.GetType ();
  79                         RuntimeType o2_type = (RuntimeType) o2.GetType ();
  80
  81                         if (o1_type != o2_type)
  82                                 return false;
  83
  84                         object[] fields;
  85                         bool res = InternalEquals (o1, o2, out fields);
  86                         if (fields == null)
  87                                 return res;
  88
  89                         for (int i = 0; i < fields.Length; i += 2) {
  90                                 object meVal = fields [i];
  91                                 object youVal = fields [i + 1];
  92                                 if (meVal == null) {
  93                                         if (youVal == null)
  94                                                 continue;
  95
  96                                         return false;
  97                                 }
  98
  99                                 if (!meVal.Equals (youVal))
 100                                         return false;
 101                         }
 102
 103                         return true;
 104                 }
 105
 106                 // <summary>
 107                 //   True if this instance and o represent the same type
 108                 //   and have the same value.
 109                 // </summary>
 110                 public override bool Equals (object obj)
 111                 {
 112                         return DefaultEquals (this, obj);
 113                 }
 114
 115                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 116                 internal extern static int InternalGetHashCode (object o, out object[] fields);
 117
 118                 // <summary>
 119                 //   Gets a hashcode for this value type using the
 120                 //   bits in the structure
 121                 // </summary>
 122                 public override int GetHashCode ()
 123                 {
 124                         object[] fields;
 125                         int result = InternalGetHashCode (this, out fields);
 126
 127                         if (fields != null)
 128                                 for (int i = 0; i < fields.Length; ++i)
 129                                         if (fields [i] != null)
 130                                                 result ^= fields [i].GetHashCode ();
 131
 132                         return result;
 133                 }
 134
 135                 internal static int GetHashCodeOfPtr (IntPtr ptr)
 136                 {
 137                         int hash_code = (int) ptr;
 138                         int seed = Internal.hash_code_of_ptr_seed;
 139
 140                         if (seed == 0) {
 141                                 /* We use the first non-0 pointer as the seed, all hashcodes will be
 142                                  * based off that. This is to make sure that we only reveal relative
 143                                  * memory addresses and never absolute ones. */
 144                                 seed = hash_code;
 145                                 Interlocked.CompareExchange (ref Internal.hash_code_of_ptr_seed, seed, 0);
 146                                 seed = Internal.hash_code_of_ptr_seed;
 147                         }
 148
 149                         return hash_code - seed;
 150                 }
 151
 152                 // <summary>
 153                 //   Stringified representation of this ValueType.
 154                 //   Must be overriden for better results, by default
 155                 //   it just returns the Type name.
 156                 // </summary>
 157                 public override string ToString ()
 158                 {
 159                         return GetType ().FullName;
 160                 }
 161         }
 162 }