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