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 override unsafe 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             _value == other._value;
  83
  84         public override unsafe int GetHashCode()
  85         {
  86 #if BIT64
  87             ulong l = (ulong)_value;
  88             return unchecked((int)l) ^ (int)(l >> 32);
  89 #else
  90             return unchecked((int)_value);
  91 #endif
  92         }
  93
  94         [Intrinsic]
  95         [NonVersionable]
  96         public unsafe uint ToUInt32()
  97         {
  98 #if BIT64
  99             return checked((uint)_value);
 100 #else
 101             return (uint)_value;
 102 #endif
 103         }
 104
 105         [Intrinsic]
 106         [NonVersionable]
 107         public unsafe ulong ToUInt64() => (ulong)_value;
 108
 109         [Intrinsic]
 110         [NonVersionable]
 111         public static explicit operator UIntPtr(uint value) =>
 112             new UIntPtr(value);
 113
 114         [Intrinsic]
 115         [NonVersionable]
 116         public static explicit operator UIntPtr(ulong value) =>
 117             new UIntPtr(value);
 118
 119         [Intrinsic]
 120         [NonVersionable]
 121         public static unsafe explicit operator UIntPtr(void* value) =>
 122             new UIntPtr(value);
 123
 124         [Intrinsic]
 125         [NonVersionable]
 126         public static unsafe explicit operator void*(UIntPtr value) =>
 127             value._value;
 128
 129         [Intrinsic]
 130         [NonVersionable]
 131         public static unsafe explicit operator uint(UIntPtr value) =>
 132 #if BIT64
 133             checked((uint)value._value);
 134 #else
 135             (uint)value._value;
 136 #endif
 137
 138         [Intrinsic]
 139         [NonVersionable]
 140         public static unsafe explicit operator ulong(UIntPtr value) =>
 141             (ulong)value._value;
 142
 143         [Intrinsic]
 144         [NonVersionable]
 145         public static unsafe bool operator ==(UIntPtr value1, UIntPtr value2) =>
 146             value1._value == value2._value;
 147
 148         [Intrinsic]
 149         [NonVersionable]
 150         public static unsafe bool operator !=(UIntPtr value1, UIntPtr value2) =>
 151             value1._value != value2._value;
 152
 153         [NonVersionable]
 154         public static UIntPtr Add(UIntPtr pointer, int offset) =>
 155             pointer + offset;
 156
 157         [Intrinsic]
 158         [NonVersionable]
 159         public static unsafe UIntPtr operator +(UIntPtr pointer, int offset) =>
 160             new UIntPtr((nuint)pointer._value + (nuint)offset);
 161
 162         [NonVersionable]
 163         public static UIntPtr Subtract(UIntPtr pointer, int offset) =>
 164             pointer - offset;
 165
 166         [Intrinsic]
 167         [NonVersionable]
 168         public static unsafe UIntPtr operator -(UIntPtr pointer, int offset) =>
 169             new UIntPtr((nuint)pointer._value - (nuint)offset);
 170
 171         public static int Size
 172         {
 173             [Intrinsic]
 174             [NonVersionable]
 175             get => sizeof(nuint);
 176         }
 177
 178         [Intrinsic]
 179         [NonVersionable]
 180         public unsafe void* ToPointer() => _value;
 181
 182         public override unsafe string ToString() =>
 183             ((nuint)_value).ToString(CultureInfo.InvariantCulture);
 184     }
 185 }