Reduce amount of code in example client

examples/aggregation/client/src/main.rs

@@ -5,51 +5,25 @@ use interface::{
 };
 
 fn main() {
-    let runtime = match Runtime::new() {
-        Ok(runtime) => {
-            println!("Got a runtime");
-            runtime
-        }
-        Err(hr) => {
-            println!("Failed to initialize COM Library: {}", hr);
-            return;
-        }
-    };
+    let runtime =
+        Runtime::new().unwrap_or_else(|hr| panic!("Failed to initialize COM Library{:x}", hr));
+    println!("Got a runtime");
 
-    run_aggr_test(runtime);
-}
-
-fn run_aggr_test(runtime: Runtime) {
-    let result = runtime.create_instance::<dyn IFileManager>(&CLSID_WINDOWS_FILE_MANAGER_CLASS);
-    let filemanager = match result {
-        Ok(filemanager) => filemanager,
-        Err(e) => {
-            println!("Failed to get filemanager, {:x}", e as u32);
-            return;
-        }
-    };
+    let file_manager = runtime
+        .create_instance::<dyn IFileManager>(&CLSID_WINDOWS_FILE_MANAGER_CLASS)
+        .unwrap_or_else(|hr| panic!("Failed to get file manager{:x}", hr));
     println!("Got filemanager!");
-    filemanager.delete_all();
+    file_manager.delete_all();
 
-    let result = filemanager.get_interface::<dyn ILocalFileManager>();
-    let lfm = match result {
-        Some(lfm) => lfm,
-        None => {
-            println!("Failed to get Local File Manager!");
-            return;
-        }
-    };
-    println!("Got Local File Manager.");
-    lfm.delete_local();
+    let local_file_manager = file_manager
+        .get_interface::<dyn ILocalFileManager>()
+        .expect("Failed to get local file manager");
+    println!("Got local lile lanager.");
+    local_file_manager.delete_local();
 
-    let result = runtime.create_instance::<dyn ILocalFileManager>(&CLSID_LOCAL_FILE_MANAGER_CLASS);
-    let localfilemanager = match result {
-        Ok(localfilemanager) => localfilemanager,
-        Err(e) => {
-            println!("Failed to get localfilemanager, {:x}", e as u32);
-            return;
-        }
-    };
+    let local_file_manager = runtime
+        .create_instance::<dyn ILocalFileManager>(&CLSID_LOCAL_FILE_MANAGER_CLASS)
+        .unwrap_or_else(|hr| panic!("Failed to get local file manager{:x}", hr));
     println!("Got localfilemanager!");
-    localfilemanager.delete_local();
+    local_file_manager.delete_local();
 }

examples/basic/client/src/main.rs

@@ -2,98 +2,51 @@ use com::{interfaces::iunknown::IUnknown, runtime::ApartmentThreadedRuntime as R
 use interface::{IAnimal, ICat, IDomesticAnimal, IExample, CLSID_CAT_CLASS};
 
 fn main() {
-    let runtime = match Runtime::new() {
-        Ok(runtime) => runtime,
-        Err(hr) => {
-            println!("Failed to initialize COM Library: {}", hr);
-            return;
-        }
-    };
+    let runtime =
+        Runtime::new().unwrap_or_else(|hr| panic!("Failed to initialize COM Library{:x}", hr));
 
-    let factory = match runtime.get_class_object(&CLSID_CAT_CLASS) {
-        Ok(factory) => {
-            println!("Got cat class object");
-            factory
-        }
-        Err(hr) => {
-            println!("Failed to get cat class object {:x}", hr as u32);
-            return;
-        }
-    };
+    let factory = runtime
+        .get_class_object(&CLSID_CAT_CLASS)
+        .unwrap_or_else(|hr| panic!("Failed to get cat class object {:x}", hr));
+    println!("Got cat class object");
 
-    let unknown = match factory.get_instance::<dyn IUnknown>() {
-        Some(unknown) => {
-            println!("Got IUnknown");
-            unknown
-        }
-        None => {
-            println!("Failed to get IUnknown");
-            return;
-        }
-    };
+    let unknown = factory
+        .get_instance::<dyn IUnknown>()
+        .expect("Failed to get IUknown");
+    println!("Got IUnknown");
 
-    let animal = match unknown.get_interface::<dyn IAnimal>() {
-        Some(animal) => {
-            println!("Got IAnimal");
-            animal
-        }
-        None => {
-            println!("Failed to get an IAnimal");
-            return;
-        }
-    };
+    let animal = unknown
+        .get_interface::<dyn IAnimal>()
+        .expect("Failed to get IAnimal");
+    println!("Got IAnimal");
 
     animal.eat();
 
     // Test cross-vtable interface queries for both directions.
-    let domestic_animal = match animal.get_interface::<dyn IDomesticAnimal>() {
-        Some(domestic_animal) => {
-            println!("Got IDomesticAnimal");
-            domestic_animal
-        }
-        None => {
-            println!("Failed to get IDomesticAnimal");
-            return;
-        }
-    };
+    let domestic_animal = animal
+        .get_interface::<dyn IDomesticAnimal>()
+        .expect("Failed to get IDomesticAnimal");
+    println!("Got IDomesticAnimal");
 
     domestic_animal.train();
 
-    let new_cat = match domestic_animal.get_interface::<dyn ICat>() {
-        Some(new_cat) => {
-            println!("Got ICat");
-            new_cat
-        }
-        None => {
-            println!("Failed to get ICat");
-            return;
-        }
-    };
+    let new_cat = domestic_animal
+        .get_interface::<dyn ICat>()
+        .expect("Failed to get ICat");
+    println!("Got ICat");
     new_cat.ignore_humans();
 
     // Test querying within second vtable.
-    let domestic_animal_two = match domestic_animal.get_interface::<dyn IDomesticAnimal>() {
-        Some(domestic_animal_two) => {
-            println!("Got IDomesticAnimal");
-            domestic_animal_two
-        }
-        None => {
-            println!("Failed to get domestic animal!");
-            return;
-        }
-    };
+    let domestic_animal_two = domestic_animal
+        .get_interface::<dyn IDomesticAnimal>()
+        .expect("Failed to get second IDomesticAnimal");
+    println!("Got IDomesticAnimal");
     domestic_animal_two.train();
 
-    let cat = match runtime.create_instance::<dyn ICat>(&CLSID_CAT_CLASS) {
-        Ok(cat) => {
-            println!("Got another cat");
-            cat
-        }
-        Err(e) => {
-            println!("Failed to get an cat, {:x}", e);
-            return;
-        }
-    };
+    let cat = runtime
+        .create_instance::<dyn ICat>(&CLSID_CAT_CLASS)
+        .unwrap_or_else(|hr| panic!("Failed to get a cat {:x}", hr));
+    println!("Got another cat");
 
     cat.eat();