Generate the bindings from the provided json file instead of bindgen (Fixes #3)

Allow us to remove the hack for accessing packed structs

1 files changed, 28 insertions, 28 deletions

diff --git a/src/user_stats.rs b/src/user_stats.rs
index 33b92a1..745b76a 100644
--- a/src/user_stats.rs
+++ b/src/user_stats.rs
@@ -23,8 +23,8 @@ impl <Manager> UserStats<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        Ok(if v.get_m_bLeaderboardFound() != 0 {
-                            Some(Leaderboard(v.get_m_hSteamLeaderboard()))
+                        Ok(if v.m_bLeaderboardFound != 0 {
+                            Some(Leaderboard(v.m_hSteamLeaderboard.0))
                         } else {
                             None
                         })
@@ -40,14 +40,14 @@ impl <Manager> UserStats<Manager> {
             let name = CString::new(name).unwrap();
 
             let sort_method = match sort_method {
-                LeaderboardSortMethod::Ascending => sys::ELeaderboardSortMethod_k_ELeaderboardSortMethodAscending,
-                LeaderboardSortMethod::Descending => sys::ELeaderboardSortMethod_k_ELeaderboardSortMethodDescending,
+                LeaderboardSortMethod::Ascending => sys::ELeaderboardSortMethod::ELeaderboardSortMethodAscending,
+                LeaderboardSortMethod::Descending => sys::ELeaderboardSortMethod::ELeaderboardSortMethodDescending,
             };
 
             let display_type = match display_type {
-	            LeaderboardDisplayType::Numeric => sys::ELeaderboardDisplayType_k_ELeaderboardDisplayTypeNumeric,
-	            LeaderboardDisplayType::TimeSeconds => sys::ELeaderboardDisplayType_k_ELeaderboardDisplayTypeTimeSeconds,
-	            LeaderboardDisplayType::TimeMilliSeconds => sys::ELeaderboardDisplayType_k_ELeaderboardDisplayTypeTimeMilliSeconds,
+	            LeaderboardDisplayType::Numeric => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeNumeric,
+	            LeaderboardDisplayType::TimeSeconds => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeTimeSeconds,
+	            LeaderboardDisplayType::TimeMilliSeconds => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeTimeMilliSeconds,
             };
 
             let api_call = sys::SteamAPI_ISteamUserStats_FindOrCreateLeaderboard(self.user_stats, name.as_ptr() as *const _, sort_method, display_type);
@@ -57,8 +57,8 @@ impl <Manager> UserStats<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        Ok(if v.get_m_bLeaderboardFound() != 0 {
-                            Some(Leaderboard(v.get_m_hSteamLeaderboard()))
+                        Ok(if v.m_bLeaderboardFound != 0 {
+                            Some(Leaderboard(v.m_hSteamLeaderboard.0))
                         } else {
                             None
                         })
@@ -72,22 +72,22 @@ impl <Manager> UserStats<Manager> {
     {
         unsafe {
             let method = match method {
-                UploadScoreMethod::KeepBest => sys::ELeaderboardUploadScoreMethod_k_ELeaderboardUploadScoreMethodKeepBest,
-                UploadScoreMethod::ForceUpdate => sys::ELeaderboardUploadScoreMethod_k_ELeaderboardUploadScoreMethodForceUpdate,
+                UploadScoreMethod::KeepBest => sys::ELeaderboardUploadScoreMethod::ELeaderboardUploadScoreMethodKeepBest,
+                UploadScoreMethod::ForceUpdate => sys::ELeaderboardUploadScoreMethod::ELeaderboardUploadScoreMethodForceUpdate,
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(self.user_stats, leaderboard.0, method, score, details.as_ptr(), details.len() as _);
+            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(self.user_stats, sys::SteamLeaderboard_t(leaderboard.0), method, score, details.as_ptr(), details.len() as _);
             register_call_result::<sys::LeaderboardScoreUploaded_t , _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 6,
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        Ok(if v.get_m_bSuccess() != 0 {
+                        Ok(if v.m_bSuccess != 0 {
                             Some(LeaderboardScoreUploaded {
-                                score: v.get_m_nScore(),
-                                was_changed: v.get_m_bScoreChanged() != 0,
-                                global_rank_new: v.get_m_nGlobalRankNew() as _,
-                                global_rank_previous: v.get_m_nGlobalRankPrevious() as _,
+                                score: v.m_nScore,
+                                was_changed: v.m_bScoreChanged != 0,
+                                global_rank_new: v.m_nGlobalRankNew as _,
+                                global_rank_previous: v.m_nGlobalRankPrevious as _,
                             })
                         } else {
                             None
@@ -108,11 +108,11 @@ impl <Manager> UserStats<Manager> {
     {
         unsafe {
             let request = match request {
-                LeaderboardDataRequest::Global => sys::ELeaderboardDataRequest_k_ELeaderboardDataRequestGlobal,
-                LeaderboardDataRequest::GlobalAroundUser => sys::ELeaderboardDataRequest_k_ELeaderboardDataRequestGlobalAroundUser,
-                LeaderboardDataRequest::Friends => sys::ELeaderboardDataRequest_k_ELeaderboardDataRequestFriends,
+                LeaderboardDataRequest::Global => sys::ELeaderboardDataRequest::ELeaderboardDataRequestGlobal,
+                LeaderboardDataRequest::GlobalAroundUser => sys::ELeaderboardDataRequest::ELeaderboardDataRequestGlobalAroundUser,
+                LeaderboardDataRequest::Friends => sys::ELeaderboardDataRequest::ELeaderboardDataRequestFriends,
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(self.user_stats, leaderboard.0, request, start as _, end as _);
+            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(self.user_stats, sys::SteamLeaderboard_t(leaderboard.0), request, start as _, end as _);
             let user_stats = self.user_stats as isize;
             register_call_result::<sys::LeaderboardScoresDownloaded_t , _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 5,
@@ -120,19 +120,19 @@ impl <Manager> UserStats<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        let len = v.get_m_cEntryCount();
+                        let len = v.m_cEntryCount;
                         let mut entries = Vec::with_capacity(len as usize);
                         for idx in 0 .. len {
-                            let mut entry = sys::create_empty_LeaderboardEntry_t();
+                            let mut entry: sys::LeaderboardEntry_t = std::mem::uninitialized();
                             let mut details = Vec::with_capacity(max_details_len);
 
-                            sys::SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(user_stats as *mut _, v.get_m_hSteamLeaderboardEntries(), idx, &mut entry, details.as_mut_ptr(), max_details_len as _);
-                            details.set_len(entry.get_m_cDetails() as usize);
+                            sys::SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(user_stats as *mut _, v.m_hSteamLeaderboardEntries, idx, &mut entry, details.as_mut_ptr(), max_details_len as _);
+                            details.set_len(entry.m_cDetails as usize);
 
                             entries.push(LeaderboardEntry {
-                                user: SteamId(entry.get_m_steamIDUser()),
-                                global_rank: entry.get_m_nGlobalRank(),
-                                score: entry.get_m_nScore(),
+                                user: SteamId(entry.m_steamIDUser.0),
+                                global_rank: entry.m_nGlobalRank,
+                                score: entry.m_nScore,
                                 details,
                             })
                         }