Adds pointer methods to native strings

ThadHouse · ThadHouse · commit 402f68c724de · 2017-06-21T22:59:04.000-07:00
Easier interop
diff --git a/src/FRC-Utilities/CachedNativeString.cs b/src/FRC-Utilities/CachedNativeString.cs
@@ -8,31 +8,32 @@ namespace FRC
     /// Holds a Cached UTF8 string to pass to native code. There is no way to initialize or dispose of this
     /// string from user code.
     /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    public struct CachedNativeString
+    public unsafe struct CachedNativeString
     {
         /// <summary>
         /// Pointer to this string, null terminated. Do not modify this pointer.
         /// </summary>
-        public IntPtr Buffer;
+        public byte* Buffer;
         /// <summary>
         /// The Length of this string without the null terminator;
         /// </summary>
         public UIntPtr Length;
 
+        private string m_string;
+
         internal CachedNativeString(string vStr)
         {
+            m_string = vStr;
             unsafe
             {
                 fixed (char* str = vStr)
                 {
                     var encoding = Encoding.UTF8;
                     int bytes = encoding.GetByteCount(str, vStr.Length);
-                    Buffer = Marshal.AllocHGlobal((bytes + 1) * sizeof(byte));
+                    Buffer = (byte*)Marshal.AllocHGlobal((bytes + 1) * sizeof(byte));
                     Length = (UIntPtr)bytes;
-                    byte* data = (byte*)Buffer.ToPointer();
-                    encoding.GetBytes(str, vStr.Length, data, bytes);
-                    data[bytes] = 0;
+                    encoding.GetBytes(str, vStr.Length, Buffer, bytes);
+                    Buffer[bytes] = 0;
                 }
             }
         }
@@ -43,7 +44,7 @@ internal CachedNativeString(string vStr)
         /// <returns>The contained string</returns>
         public override string ToString()
         {
-            return UTF8String.ReadUTF8String(Buffer, Length);
+            return m_string;
         }
     }
 }
diff --git a/src/FRC-Utilities/DisposableNativeString.cs b/src/FRC-Utilities/DisposableNativeString.cs
@@ -9,45 +9,47 @@ namespace FRC
     /// <summary>
     /// Holds a UTF8 string to pass to native code. Make sure to properly dispose of this to avoid a memory leak
     /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    public struct DisposableNativeString : IDisposable
+    public unsafe struct DisposableNativeString : IDisposable
     {
         /// <summary>
         /// Pointer to this string, null terminated. Do not modify this pointer.
         /// </summary>
-        public IntPtr Buffer;
+        public byte* Buffer;
         /// <summary>
         /// The Length of this string without the null terminator;
         /// </summary>
         public UIntPtr Length;
 
+        private string m_string;
+
         /// <summary>
         /// Creates a new UTF8 string from a managed string
         /// </summary>
         /// <param name="vStr">The managed string</param>
         public DisposableNativeString(string vStr)
         {
+            m_string = vStr;
             unsafe
             {
                 fixed (char* str = vStr)
                 {
                     var encoding = Encoding.UTF8;
                     int bytes = encoding.GetByteCount(str, vStr.Length);
-                    Buffer = Marshal.AllocHGlobal((bytes + 1) * sizeof(byte));
+                    Buffer = (byte*)Marshal.AllocHGlobal((bytes + 1) * sizeof(byte));
                     Length = (UIntPtr)bytes;
-                    byte* data = (byte*)Buffer.ToPointer();
-                    encoding.GetBytes(str, vStr.Length, data, bytes);
-                    data[bytes] = 0;
+                    encoding.GetBytes(str, vStr.Length, Buffer, bytes);
+                    Buffer[bytes] = 0;
                 }
             }
         }
 
         /// <summary>
         /// Disposes of the native string
         /// </summary>
-        public void Dispose()
+        public unsafe void Dispose()
         {
-            Marshal.FreeHGlobal(Buffer);
+            Marshal.FreeHGlobal((IntPtr)Buffer);
+            m_string = null;
         }
 
         /// <summary>
@@ -56,7 +58,7 @@ public void Dispose()
         /// <returns>The contained string</returns>
         public override string ToString()
         {
-            return UTF8String.ReadUTF8String(Buffer, Length);
+            return m_string;
         }
     }
 }
diff --git a/src/FRC-Utilities/UTF8String.cs b/src/FRC-Utilities/UTF8String.cs
@@ -12,14 +12,16 @@ public static class UTF8String
     {
         private static readonly ConcurrentDictionary<string, CachedNativeString> s_stringCache = new ConcurrentDictionary<string, CachedNativeString>();
 
+        private static Func<string, CachedNativeString> CacheCreateFunc = (s) => new CachedNativeString(s);
+
         /// <summary>
         /// Creates a UTF8 string that will be cached, using the already cached string is already created
         /// </summary>
         /// <param name="str">The string to cache</param>
         /// <returns>The cached UTF8 string</returns>
         public static CachedNativeString CreateCachedUTF8String(string str)
         {
-            return s_stringCache.GetOrAdd(str, s => new CachedNativeString(s));
+            return s_stringCache.GetOrAdd(str, CacheCreateFunc);
         }
 
         /// <summary>
@@ -57,12 +59,36 @@ public static string ReadUTF8String(IntPtr str, UIntPtr size)
 #else
                 int iSize = (int)size.ToUInt64();
                 byte[] data = new byte[iSize];
-                Marshal.Copy(str, data, 0, iSize);
+                for (int i = 0; i < iSize; i++)
+                {
+                    data[i] = ((byte*)str)[i];
+                }
                 return Encoding.UTF8.GetString(data);
 #endif
             }
         }
 
+        /// <summary>
+        /// Reads a UTF8 string from a native pointer.
+        /// </summary>
+        /// <param name="str">The pointer to read from</param>
+        /// <param name="size">The length of the string</param>
+        /// <returns>The managed string</returns>
+        public static unsafe string ReadUTF8String(byte* str, UIntPtr size)
+        {
+#if (!NET451)
+            return Encoding.UTF8.GetString(str, (int)size);
+#else
+            int iSize = (int)size.ToUInt64();
+            byte[] data = new byte[iSize];
+            for (int i = 0; i < iSize; i++)
+            {
+                data[i] = str[i];
+            }
+            return Encoding.UTF8.GetString(data);
+#endif
+        }
+
         /// <summary>
         /// Reads a UTF8 string from a null termincated native pointer
         /// </summary>
@@ -82,9 +108,30 @@ public static string ReadUTF8String(IntPtr str)
                     }
                     count++;
                 }
-                
+
                 return ReadUTF8String(str, (UIntPtr)count);
             }
         }
+
+        /// <summary>
+        /// Reads a UTF8 string from a null termincated native pointer
+        /// </summary>
+        /// <param name="str">The pointer to read from (must be null terminated)</param>
+        /// <returns>The managed string</returns>
+        public static unsafe string ReadUTF8String(byte* str)
+        {
+            byte* data = str;
+            int count = 0;
+            while (true)
+            {
+                if (data[count] == 0)
+                {
+                    break;
+                }
+                count++;
+            }
+
+            return ReadUTF8String(str, (UIntPtr)count);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -8,31 +8,32 @@ namespace FRC`
`8`	`8`	`/// Holds a Cached UTF8 string to pass to native code. There is no way to initialize or dispose of this`
`9`	`9`	`/// string from user code.`
`10`	`10`	`/// </summary>`
`11`		`- [StructLayout(LayoutKind.Sequential)]`
`12`		`- public struct CachedNativeString`
	`11`	`+ public unsafe struct CachedNativeString`
`13`	`12`	`{`
`14`	`13`	`/// <summary>`
`15`	`14`	`/// Pointer to this string, null terminated. Do not modify this pointer.`
`16`	`15`	`/// </summary>`
`17`		`- public IntPtr Buffer;`
	`16`	`+ public byte* Buffer;`
`18`	`17`	`/// <summary>`
`19`	`18`	`/// The Length of this string without the null terminator;`
`20`	`19`	`/// </summary>`
`21`	`20`	`public UIntPtr Length;`
`22`	`21`
	`22`	`+ private string m_string;`
	`23`	`+`
`23`	`24`	`internal CachedNativeString(string vStr)`
`24`	`25`	`{`
	`26`	`+ m_string = vStr;`
`25`	`27`	`unsafe`
`26`	`28`	`{`
`27`	`29`	`fixed (char* str = vStr)`
`28`	`30`	`{`
`29`	`31`	`var encoding = Encoding.UTF8;`
`30`	`32`	`int bytes = encoding.GetByteCount(str, vStr.Length);`
`31`		`- Buffer = Marshal.AllocHGlobal((bytes + 1) * sizeof(byte));`
	`33`	`+ Buffer = (byte)Marshal.AllocHGlobal((bytes + 1) sizeof(byte));`
`32`	`34`	`Length = (UIntPtr)bytes;`
`33`		`- byte* data = (byte*)Buffer.ToPointer();`
`34`		`- encoding.GetBytes(str, vStr.Length, data, bytes);`
`35`		`- data[bytes] = 0;`
	`35`	`+ encoding.GetBytes(str, vStr.Length, Buffer, bytes);`
	`36`	`+ Buffer[bytes] = 0;`
`36`	`37`	`}`
`37`	`38`	`}`
`38`	`39`	`}`
`@@ -43,7 +44,7 @@ internal CachedNativeString(string vStr)`
`43`	`44`	`/// <returns>The contained string</returns>`
`44`	`45`	`public override string ToString()`
`45`	`46`	`{`
`46`		`- return UTF8String.ReadUTF8String(Buffer, Length);`
	`47`	`+ return m_string;`
`47`	`48`	`}`
`48`	`49`	`}`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,45 +9,47 @@ namespace FRC`
`9`	`9`	`/// <summary>`
`10`	`10`	`/// Holds a UTF8 string to pass to native code. Make sure to properly dispose of this to avoid a memory leak`
`11`	`11`	`/// </summary>`
`12`		`- [StructLayout(LayoutKind.Sequential)]`
`13`		`- public struct DisposableNativeString : IDisposable`
	`12`	`+ public unsafe struct DisposableNativeString : IDisposable`
`14`	`13`	`{`
`15`	`14`	`/// <summary>`
`16`	`15`	`/// Pointer to this string, null terminated. Do not modify this pointer.`
`17`	`16`	`/// </summary>`
`18`		`- public IntPtr Buffer;`
	`17`	`+ public byte* Buffer;`
`19`	`18`	`/// <summary>`
`20`	`19`	`/// The Length of this string without the null terminator;`
`21`	`20`	`/// </summary>`
`22`	`21`	`public UIntPtr Length;`
`23`	`22`
	`23`	`+ private string m_string;`
	`24`	`+`
`24`	`25`	`/// <summary>`
`25`	`26`	`/// Creates a new UTF8 string from a managed string`
`26`	`27`	`/// </summary>`
`27`	`28`	`/// <param name="vStr">The managed string</param>`
`28`	`29`	`public DisposableNativeString(string vStr)`
`29`	`30`	`{`
	`31`	`+ m_string = vStr;`
`30`	`32`	`unsafe`
`31`	`33`	`{`
`32`	`34`	`fixed (char* str = vStr)`
`33`	`35`	`{`
`34`	`36`	`var encoding = Encoding.UTF8;`
`35`	`37`	`int bytes = encoding.GetByteCount(str, vStr.Length);`
`36`		`- Buffer = Marshal.AllocHGlobal((bytes + 1) * sizeof(byte));`
	`38`	`+ Buffer = (byte)Marshal.AllocHGlobal((bytes + 1) sizeof(byte));`
`37`	`39`	`Length = (UIntPtr)bytes;`
`38`		`- byte* data = (byte*)Buffer.ToPointer();`
`39`		`- encoding.GetBytes(str, vStr.Length, data, bytes);`
`40`		`- data[bytes] = 0;`
	`40`	`+ encoding.GetBytes(str, vStr.Length, Buffer, bytes);`
	`41`	`+ Buffer[bytes] = 0;`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`/// <summary>`
`46`	`47`	`/// Disposes of the native string`
`47`	`48`	`/// </summary>`
`48`		`- public void Dispose()`
	`49`	`+ public unsafe void Dispose()`
`49`	`50`	`{`
`50`		`- Marshal.FreeHGlobal(Buffer);`
	`51`	`+ Marshal.FreeHGlobal((IntPtr)Buffer);`
	`52`	`+ m_string = null;`
`51`	`53`	`}`
`52`	`54`
`53`	`55`	`/// <summary>`
`@@ -56,7 +58,7 @@ public void Dispose()`
`56`	`58`	`/// <returns>The contained string</returns>`
`57`	`59`	`public override string ToString()`
`58`	`60`	`{`
`59`		`- return UTF8String.ReadUTF8String(Buffer, Length);`
	`61`	`+ return m_string;`
`60`	`62`	`}`
`61`	`63`	`}`
`62`	`64`	`}`