Refactor: extract repeated code in find_api_ptr.

Author: stewbasic

gdnative-sys/src/lib.rs

@@ -27,59 +27,78 @@ fn map_option_to_init_error<T>(t: Option<T>, message: &'static str) -> Result<T,
     }
 }
 
-unsafe fn find_api_ptr(
-    core_api: *const godot_gdnative_core_api_struct,
+unsafe fn find_version(
+    mut api: *const godot_gdnative_api_struct,
     api_type: GDNATIVE_API_TYPES,
     version_major: u32,
     version_minor: u32,
-) -> Result<*const godot_gdnative_api_struct, InitError> {
+) -> Option<Result<*const godot_gdnative_api_struct, InitError>> {
     let mut got = None;
-    let mut api = core_api as *const godot_gdnative_api_struct;
     if (*api).type_ as u32 == api_type as u32 {
         while !api.is_null() {
             // The boolean expression below SHOULD always be true;
             // we will double check to be safe.
             if (*api).type_ as u32 == api_type as u32 {
                 let (major, minor) = ((*api).version.major, (*api).version.minor);
                 if major == version_major && minor == version_minor {
-                    return Ok(api);
+                    return Some(Ok(api));
                 } else {
                     got = Some(godot_gdnative_api_version { major, minor });
                 }
             }
             api = (*api).next;
         }
     }
-    for i in 0..(*core_api).num_extensions {
-        let mut extension =
-            *(*core_api).extensions.offset(i as _) as *const godot_gdnative_api_struct;
-        if (*extension).type_ as u32 == api_type as u32 {
-            while !extension.is_null() {
-                // The boolean expression below SHOULD always be true;
-                // we will double check to be safe.
-                if (*extension).type_ as u32 == api_type as u32 {
-                    let (major, minor) = ((*extension).version.major, (*extension).version.minor);
-                    if major == version_major && minor == version_minor {
-                        return Ok(extension);
-                    } else {
-                        got = Some(godot_gdnative_api_version { major, minor });
-                    }
-                }
-                extension = (*extension).next;
-            }
-        }
-    }
-    match got {
-        Some(got) => Err(InitError::VersionMismatch {
+    got.map(|got| {
+        Err(InitError::VersionMismatch {
             want: godot_gdnative_api_version {
                 major: version_major,
                 minor: version_minor,
             },
             got,
             api_type,
-        }),
-        None => Err(InitError::Generic {
-            message: format!("Couldn't find API struct with type {}", api_type),
-        }),
+        })
+    })
+}
+
+unsafe fn find_api_ptr(
+    core_api: *const godot_gdnative_core_api_struct,
+    api_type: GDNATIVE_API_TYPES,
+    version_major: u32,
+    version_minor: u32,
+) -> Result<*const godot_gdnative_api_struct, InitError> {
+    let mut last_error = None;
+    match find_version(
+        core_api as *const godot_gdnative_api_struct,
+        api_type,
+        version_major,
+        version_minor,
+    ) {
+        Some(Ok(api)) => {
+            return Ok(api);
+        }
+        Some(Err(error)) => {
+            last_error = Some(error);
+        }
+        None => {}
+    }
+    for i in 0..(*core_api).num_extensions {
+        match find_version(
+            *(*core_api).extensions.offset(i as _),
+            api_type,
+            version_major,
+            version_minor,
+        ) {
+            Some(Ok(api)) => {
+                return Ok(api);
+            }
+            Some(Err(error)) => {
+                last_error = Some(error);
+            }
+            None => {}
+        }
     }
+    Err(last_error.unwrap_or(InitError::Generic {
+        message: format!("Couldn't find API struct with type {}", api_type),
+    }))
 }