Initial code.

SAM.API/Wrappers/SteamClient009.cs

@@ -0,0 +1,200 @@
+/* Copyright (c) 2017 Rick (rick 'at' gibbed 'dot' us)
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would
+ *    be appreciated but is not required.
+ * 
+ * 2. Altered source versions must be plainly marked as such, and must not
+ *    be misrepresented as being the original software.
+ * 
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using SAM.API.Interfaces;
+
+namespace SAM.API.Wrappers
+{
+    public class SteamClient009 : NativeWrapper<ISteamClient009>
+    {
+        #region CreateSteamPipe
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate int NativeCreateSteamPipe(IntPtr self);
+
+        public int CreateSteamPipe()
+        {
+            return this.Call<int, NativeCreateSteamPipe>(this.Functions.CreateSteamPipe, this.ObjectAddress);
+        }
+        #endregion
+
+        #region ReleaseSteamPipe
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        private delegate bool NativeReleaseSteamPipe(IntPtr self);
+
+        public bool ReleaseSteamPipe(int pipe)
+        {
+            return this.Call<bool, NativeReleaseSteamPipe>(this.Functions.ReleaseSteamPipe, this.ObjectAddress);
+        }
+        #endregion
+
+        #region CreateLocalUser
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate int NativeCreateLocalUser(IntPtr self, ref int pipe, Types.AccountType type);
+
+        public int CreateLocalUser(ref int pipe, Types.AccountType type)
+        {
+            var call = this.GetFunction<NativeCreateLocalUser>(this.Functions.CreateLocalUser);
+            return call(this.ObjectAddress, ref pipe, type);
+        }
+        #endregion
+
+        #region ConnectToGlobalUser
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate int NativeConnectToGlobalUser(IntPtr self, int pipe);
+
+        public int ConnectToGlobalUser(int pipe)
+        {
+            return this.Call<int, NativeConnectToGlobalUser>(
+                this.Functions.ConnectToGlobalUser,
+                this.ObjectAddress,
+                pipe);
+        }
+        #endregion
+
+        #region ReleaseUser
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate void NativeReleaseUser(IntPtr self, int pipe, int user);
+
+        public void ReleaseUser(int pipe, int user)
+        {
+            this.Call<NativeReleaseUser>(this.Functions.ReleaseUser, this.ObjectAddress, pipe, user);
+        }
+        #endregion
+
+        #region SetLocalIPBinding
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate void NativeSetLocalIPBinding(IntPtr self, uint host, ushort port);
+
+        public void SetLocalIPBinding(uint host, ushort port)
+        {
+            this.Call<NativeSetLocalIPBinding>(this.Functions.SetLocalIPBinding, this.ObjectAddress, host, port);
+        }
+        #endregion
+
+        #region GetISteamUser
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate IntPtr NativeGetISteamUser(IntPtr self, int user, int pipe, string version);
+
+        private TClass GetISteamUser<TClass>(int user, int pipe, string version)
+            where TClass : INativeWrapper, new()
+        {
+            IntPtr address = this.Call<IntPtr, NativeGetISteamUser>(
+                this.Functions.GetISteamUser,
+                this.ObjectAddress,
+                user,
+                pipe,
+                version);
+            var result = new TClass();
+            result.SetupFunctions(address);
+            return result;
+        }
+        #endregion
+
+        #region GetSteamUser012
+        public SteamUser012 GetSteamUser012(int user, int pipe)
+        {
+            return this.GetISteamUser<SteamUser012>(user, pipe, "SteamUser012");
+        }
+        #endregion
+
+        #region GetISteamUserStats
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate IntPtr NativeGetISteamUserStats(IntPtr self, int user, int pipe, string version);
+
+        private TClass GetISteamUserStats<TClass>(int user, int pipe, string version)
+            where TClass : INativeWrapper, new()
+        {
+            IntPtr address = this.Call<IntPtr, NativeGetISteamUserStats>(
+                this.Functions.GetISteamUserStats,
+                this.ObjectAddress,
+                user,
+                pipe,
+                version);
+            var result = new TClass();
+            result.SetupFunctions(address);
+            return result;
+        }
+        #endregion
+
+        #region GetSteamUserStats007
+        public SteamUserStats007 GetSteamUserStats006(int user, int pipe)
+        {
+            return this.GetISteamUserStats<SteamUserStats007>(user, pipe, "STEAMUSERSTATS_INTERFACE_VERSION007");
+        }
+        #endregion
+
+        #region GetISteamUtils
+        [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
+        private delegate IntPtr NativeGetISteamUtils(IntPtr self, int pipe, string version);
+
+        public TClass GetISteamUtils<TClass>(int pipe, string version)
+            where TClass : INativeWrapper, new()
+        {
+            IntPtr address = this.Call<IntPtr, NativeGetISteamUtils>(
+                this.Functions.GetISteamUtils,
+                this.ObjectAddress,
+                pipe,
+                version);
+            var result = new TClass();
+            result.SetupFunctions(address);
+            return result;
+        }
+        #endregion
+
+        #region GetSteamUtils004
+        public SteamUtils005 GetSteamUtils004(int pipe)
+        {
+            return this.GetISteamUtils<SteamUtils005>(pipe, "SteamUtils005");
+        }
+        #endregion
+
+        #region GetISteamApps
+        private delegate IntPtr NativeGetISteamApps(int user, int pipe, string version);
+
+        private TClass GetISteamApps<TClass>(int user, int pipe, string version)
+            where TClass : INativeWrapper, new()
+        {
+            IntPtr address = this.Call<IntPtr, NativeGetISteamApps>(this.Functions.GetISteamApps, user, pipe, version);
+            var result = new TClass();
+            result.SetupFunctions(address);
+            return result;
+        }
+        #endregion
+
+        #region GetSteamApps001
+        public SteamApps001 GetSteamApps001(int user, int pipe)
+        {
+            return this.GetISteamApps<SteamApps001>(user, pipe, "STEAMAPPS_INTERFACE_VERSION001");
+        }
+        #endregion
+
+        #region GetSteamApps003
+        public SteamApps003 GetSteamApps003(int user, int pipe)
+        {
+            return this.GetISteamApps<SteamApps003>(user, pipe, "STEAMAPPS_INTERFACE_VERSION003");
+        }
+        #endregion
+    }
+}