netcore/System.Private.CoreLib/shared/System/UIntPtr.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.Globalization;
   6 using System.Runtime.CompilerServices;
   7 using System.Runtime.Serialization;
   8 using System.Runtime.Versioning;
   9
  10 #if BIT64
  11 using nuint = System.UInt64;
  12 #else
  13 using nuint = System.UInt32;
  14 #endif
  15
  16 namespace System
  17 {
  18     [Serializable]
  19     [CLSCompliant(false)]
  20     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  21     public readonly struct UIntPtr : IEquatable<UIntPtr>, ISerializable
  22     {
  23         private readonly unsafe void* _value; // Do not rename (binary serialization)
  24
  25         [Intrinsic]
  26         public static readonly UIntPtr Zero;
  27
  28         [Intrinsic]
  29         [NonVersionable]
  30         public unsafe UIntPtr(uint value)
  31         {
  32             _value = (void*)value;
  33         }
  34
  35         [Intrinsic]
  36         [NonVersionable]
  37         public unsafe UIntPtr(ulong value)
  38         {
  39 #if BIT64
  40             _value = (void*)value;
  41 #else
  42             _value = (void*)checked((uint)value);
  43 #endif
  44         }
  45
  46         [Intrinsic]
  47         [NonVersionable]
  48         public unsafe UIntPtr(void* value)
  49         {
  50             _value = value;
  51         }
  52
  53         private unsafe UIntPtr(SerializationInfo info, StreamingContext context)
  54         {
  55             ulong l = info.GetUInt64("value");
  56
  57             if (Size == 4 && l > uint.MaxValue)
  58                 throw new ArgumentException(SR.Serialization_InvalidPtrValue);
  59
  60             _value = (void*)l;
  61         }
  62
  63         void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
  64         {
  65             if (info == null)
  66                 throw new ArgumentNullException(nameof(info));
  67
  68             info.AddValue("value", ToUInt64());
  69         }
  70
  71         public unsafe override bool Equals(object? obj)
  72         {
  73             if (obj is UIntPtr)
  74             {
  75                 return (_value == ((UIntPtr)obj)._value);
  76             }
  77             return false;
  78         }
  79
  80         unsafe bool IEquatable<UIntPtr>.Equals(UIntPtr other)
  81         {
  82             return _value == other._value;
  83         }
  84
  85         public unsafe override int GetHashCode()
  86         {
  87 #if BIT64
  88             ulong l = (ulong)_value;
  89             return (unchecked((int)l) ^ (int)(l >> 32));
  90 #else
  91             return unchecked((int)_value);
  92 #endif
  93         }
  94
  95         [Intrinsic]
  96         [NonVersionable]
  97         public unsafe uint ToUInt32()
  98         {
  99 #if BIT64
 100             return checked((uint)_value);
 101 #else
 102             return (uint)_value;
 103 #endif
 104         }
 105
 106         [Intrinsic]
 107         [NonVersionable]
 108         public unsafe ulong ToUInt64()
 109         {
 110             return (ulong)_value;
 111         }
 112
 113         [Intrinsic]
 114         [NonVersionable]
 115         public static explicit operator UIntPtr(uint value)
 116         {
 117             return new UIntPtr(value);
 118         }
 119
 120         [Intrinsic]
 121         [NonVersionable]
 122         public static explicit operator UIntPtr(ulong value)
 123         {
 124             return new UIntPtr(value);
 125         }
 126
 127         [Intrinsic]
 128         [NonVersionable]
 129         public static unsafe explicit operator UIntPtr(void* value)
 130         {
 131             return new UIntPtr(value);
 132         }
 133
 134         [Intrinsic]
 135         [NonVersionable]
 136         public static unsafe explicit operator void* (UIntPtr value)
 137         {
 138             return value._value;
 139         }
 140
 141         [Intrinsic]
 142         [NonVersionable]
 143         public static unsafe explicit operator uint(UIntPtr value)
 144         {
 145 #if BIT64
 146             return checked((uint)value._value);
 147 #else
 148             return (uint)value._value;
 149 #endif
 150         }
 151
 152         [Intrinsic]
 153         [NonVersionable]
 154         public static unsafe explicit operator ulong(UIntPtr value)
 155         {
 156             return (ulong)value._value;
 157         }
 158
 159         [Intrinsic]
 160         [NonVersionable]
 161         public static unsafe bool operator ==(UIntPtr value1, UIntPtr value2)
 162         {
 163             return value1._value == value2._value;
 164         }
 165
 166         [Intrinsic]
 167         [NonVersionable]
 168         public static unsafe bool operator !=(UIntPtr value1, UIntPtr value2)
 169         {
 170             return value1._value != value2._value;
 171         }
 172
 173         [NonVersionable]
 174         public static UIntPtr Add(UIntPtr pointer, int offset)
 175         {
 176             return pointer + offset;
 177         }
 178
 179         [Intrinsic]
 180         [NonVersionable]
 181         public static unsafe UIntPtr operator +(UIntPtr pointer, int offset)
 182         {
 183             return new UIntPtr((nuint)pointer._value + (nuint)offset);
 184         }
 185
 186         [NonVersionable]
 187         public static UIntPtr Subtract(UIntPtr pointer, int offset)
 188         {
 189             return pointer - offset;
 190         }
 191
 192         [Intrinsic]
 193         [NonVersionable]
 194         public static unsafe UIntPtr operator -(UIntPtr pointer, int offset)
 195         {
 196             return new UIntPtr((nuint)pointer._value - (nuint)offset);
 197         }
 198
 199         public static int Size
 200         {
 201             [Intrinsic]
 202             [NonVersionable]
 203             get
 204             {
 205                 return sizeof(nuint);
 206             }
 207         }
 208
 209         [Intrinsic]
 210         [NonVersionable]
 211         public unsafe void* ToPointer()
 212         {
 213             return _value;
 214         }
 215
 216         public unsafe override string ToString()
 217         {
 218             return ((nuint)_value).ToString(CultureInfo.InvariantCulture);
 219         }
 220     }
 221 }