Remove cpp 17 features and implement Rust into CPP

cpp/examples/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.15)
 project(IdeviceFFI CXX)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

cpp/examples/app_service.cpp

@@ -9,6 +9,7 @@
 #include <idevice++/app_service.hpp>
 #include <idevice++/core_device_proxy.hpp>
 #include <idevice++/ffi.hpp>
+#include <idevice++/option.hpp>
 #include <idevice++/provider.hpp>
 #include <idevice++/readwrite.hpp>
 #include <idevice++/rsd.hpp>
@@ -16,8 +17,9 @@
 
 using namespace IdeviceFFI;
 
+[[noreturn]]
 static void die(const char* msg, const FfiError& e) {
-    std::cerr << msg << ": " << e.message << "\n";
+    std::cerr << msg << ": " << e.message << "(" << e.code << ")\n";
     std::exit(1);
 }
 
@@ -42,26 +44,25 @@ int main(int argc, char** argv) {
     FfiError    err;
 
     // 1) Connect to usbmuxd and pick first device
-    auto        mux = UsbmuxdConnection::default_new(/*tag*/ 0, err);
-    if (!mux)
-        die("failed to connect to usbmuxd", err);
+    auto        mux = UsbmuxdConnection::default_new(/*tag*/ 0);
+    if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
 
-    auto devices = mux->get_devices(err);
-    if (!devices)
-        die("failed to list devices", err);
-    if (devices->empty()) {
+    auto devices_res = mux.unwrap().get_devices();
+    if_let_err(devices_res, err, { die("failed to list devices", err); });
+    auto& devices = devices_res.unwrap();
+    if (devices.empty()) {
         std::cerr << "no devices connected\n";
         return 1;
     }
-    auto& dev  = (*devices)[0];
+    auto& dev  = (devices)[0];
 
     auto  udid = dev.get_udid();
-    if (!udid) {
+    if (udid.is_none()) {
         std::cerr << "device has no UDID\n";
         return 1;
     }
     auto mux_id = dev.get_id();
-    if (!mux_id) {
+    if (mux_id.is_none()) {
         std::cerr << "device has no mux id\n";
         return 1;
     }
@@ -72,53 +73,49 @@ int main(int argc, char** argv) {
     const uint32_t    tag   = 0;
     const std::string label = "app_service-jkcoxson";
 
-    auto provider = Provider::usbmuxd_new(std::move(addr), tag, *udid, *mux_id, label, err);
-    if (!provider)
-        die("failed to create provider", err);
+    auto              provider_res =
+        Provider::usbmuxd_new(std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label);
+    if_let_err(provider_res, err, { die("failed to create provider", err); });
+    auto& provider = provider_res.unwrap();
 
     // 3) CoreDeviceProxy
-    auto cdp = CoreDeviceProxy::connect(*provider, err);
-    if (!cdp)
-        die("failed to connect CoreDeviceProxy", err);
+    auto  cdp      = CoreDeviceProxy::connect(provider).unwrap_or_else(
+        [](FfiError e) -> CoreDeviceProxy { die("failed to connect CoreDeviceProxy", e); });
 
-    auto rsd_port = cdp->get_server_rsd_port(err);
-    if (!rsd_port)
-        die("failed to get server RSD port", err);
+    auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
+        [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
 
     // 4) Create software tunnel adapter (consumes proxy)
-    auto adapter = std::move(*cdp).create_tcp_adapter(err);
-    if (!adapter)
-        die("failed to create software tunnel adapter", err);
+    auto adapter = std::move(cdp).create_tcp_adapter();
+    if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); });
 
     // 5) Connect adapter to RSD → ReadWrite stream
-    auto stream = adapter->connect(*rsd_port, err);
-    if (!stream)
-        die("failed to connect RSD stream", err);
+    auto stream = adapter.unwrap().connect(rsd_port);
+    if_let_err(stream, err, { die("failed to connect RSD stream", err); });
 
     // 6) RSD handshake (consumes stream)
-    auto rsd = RsdHandshake::from_socket(std::move(*stream), err);
-    if (!rsd)
-        die("failed RSD handshake", err);
+    auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap()));
+    if_let_err(rsd, err, { die("failed RSD handshake", err); });
 
     // 7) AppService over RSD (borrows adapter + handshake)
-    auto app = AppService::connect_rsd(*adapter, *rsd, err);
-    if (!app)
-        die("failed to connect AppService", err);
+    auto app = AppService::connect_rsd(adapter.unwrap(), rsd.unwrap())
+                   .unwrap_or_else([&](FfiError e) -> AppService {
+                       die("failed to connect AppService", e); // never returns
+                   });
 
     // 8) Commands
     if (cmd == "list") {
-        auto apps = app->list_apps(/*app_clips*/ true,
-                                   /*removable*/ true,
-                                   /*hidden*/ true,
-                                   /*internal*/ true,
-                                   /*default_apps*/ true,
-                                   err);
-        if (!apps)
-            die("list_apps failed", err);
+        auto apps = app.list_apps(/*app_clips*/ true,
+                                  /*removable*/ true,
+                                  /*hidden*/ true,
+                                  /*internal*/ true,
+                                  /*default_apps*/ true)
+                        .unwrap_or_else(
+                            [](FfiError e) -> std::vector<AppInfo> { die("list_apps failed", e); });
 
-        for (const auto& a : *apps) {
-            std::cout << "- " << a.bundle_identifier << " | name=" << a.name
-                      << " | version=" << (a.version ? *a.version : std::string("<none>"))
+        for (const auto& a : apps) {
+            std::cout << "- " << a.bundle_identifier << " | name=" << a.name << " | version="
+                      << (a.version.is_some() ? a.version.unwrap() : std::string("<none>"))
                       << " | dev=" << (a.is_developer_app ? "y" : "n")
                       << " | hidden=" << (a.is_hidden ? "y" : "n") << "\n";
         }
@@ -132,27 +129,27 @@ int main(int argc, char** argv) {
         std::string              bundle_id = argv[2];
 
         std::vector<std::string> args; // empty in this example
-        auto                     resp = app->launch(bundle_id,
-                                args,
-                                /*kill_existing*/ false,
-                                /*start_suspended*/ false,
-                                err);
-        if (!resp)
-            die("launch failed", err);
+        auto                     resp =
+            app.launch(bundle_id,
+                       args,
+                       /*kill_existing*/ false,
+                       /*start_suspended*/ false)
+                .unwrap_or_else([](FfiError e) -> LaunchResponse { die("launch failed", e); });
 
-        std::cout << "Launched pid=" << resp->pid << " exe=" << resp->executable_url
-                  << " piv=" << resp->process_identifier_version
-                  << " audit_token_len=" << resp->audit_token.size() << "\n";
+        std::cout << "Launched pid=" << resp.pid << " exe=" << resp.executable_url
+                  << " piv=" << resp.process_identifier_version
+                  << " audit_token_len=" << resp.audit_token.size() << "\n";
         return 0;
 
     } else if (cmd == "processes") {
-        auto procs = app->list_processes(err);
-        if (!procs)
-            die("list_processes failed", err);
+        auto procs = app.list_processes().unwrap_or_else(
+            [](FfiError e) -> std::vector<ProcessToken> { die("list_processes failed", e); });
 
-        for (const auto& p : *procs) {
+        for (const auto& p : procs) {
             std::cout << p.pid << " : "
-                      << (p.executable_url ? *p.executable_url : std::string("<none>")) << "\n";
+                      << (p.executable_url.is_some() ? p.executable_url.unwrap()
+                                                     : std::string("<none>"))
+                      << "\n";
         }
         return 0;
 
@@ -163,8 +160,7 @@ int main(int argc, char** argv) {
         }
         std::string bundle_id = argv[2];
 
-        if (!app->uninstall(bundle_id, err))
-            die("uninstall failed", err);
+        if_let_err(app.uninstall(bundle_id), err, { die("uninstall failed", err); });
         std::cout << "Uninstalled " << bundle_id << "\n";
         return 0;
 
@@ -176,13 +172,14 @@ int main(int argc, char** argv) {
         uint32_t pid    = static_cast<uint32_t>(std::stoul(argv[2]));
         uint32_t signal = static_cast<uint32_t>(std::stoul(argv[3]));
 
-        auto     res    = app->send_signal(pid, signal, err);
-        if (!res)
-            die("send_signal failed", err);
+        auto res = app.send_signal(pid, signal).unwrap_or_else([](FfiError e) -> SignalResponse {
+            die("send_signal failed", e);
+        });
 
-        std::cout << "Signaled pid=" << res->pid << " signal=" << res->signal
-                  << " ts_ms=" << res->device_timestamp_ms
-                  << " exe=" << (res->executable_url ? *res->executable_url : std::string("<none>"))
+        std::cout << "Signaled pid=" << res.pid << " signal=" << res.signal
+                  << " ts_ms=" << res.device_timestamp_ms << " exe="
+                  << (res.executable_url.is_some() ? res.executable_url.unwrap()
+                                                   : std::string("<none>"))
                   << "\n";
         return 0;
 
@@ -196,22 +193,22 @@ int main(int argc, char** argv) {
         float       hw        = (argc >= 5) ? std::stof(argv[4]) : 1.0f;
         float       scale     = (argc >= 6) ? std::stof(argv[5]) : 1.0f;
 
-        auto icon = app->fetch_icon(bundle_id, hw, hw, scale, /*allow_placeholder*/ true, err);
-        if (!icon)
-            die("fetch_app_icon failed", err);
+        auto        icon =
+            app.fetch_icon(bundle_id, hw, hw, scale, /*allow_placeholder*/ true)
+                .unwrap_or_else([](FfiError e) -> IconData { die("fetch_app_icon failed", e); });
 
         std::ofstream out(save_path, std::ios::binary);
         if (!out) {
             std::cerr << "Failed to open " << save_path << " for writing\n";
             return 1;
         }
-        out.write(reinterpret_cast<const char*>(icon->data.data()),
-                  static_cast<std::streamsize>(icon->data.size()));
+        out.write(reinterpret_cast<const char*>(icon.data.data()),
+                  static_cast<std::streamsize>(icon.data.size()));
         out.close();
 
-        std::cout << "Saved icon to " << save_path << " (" << icon->data.size() << " bytes, "
-                  << icon->icon_width << "x" << icon->icon_height << ", min " << icon->minimum_width
-                  << "x" << icon->minimum_height << ")\n";
+        std::cout << "Saved icon to " << save_path << " (" << icon.data.size() << " bytes, "
+                  << icon.icon_width << "x" << icon.icon_height << ", min " << icon.minimum_width
+                  << "x" << icon.minimum_height << ")\n";
         return 0;
 
     } else {

cpp/examples/debug_proxy.cpp

@@ -8,10 +8,14 @@
 #include <idevice++/core_device_proxy.hpp>
 #include <idevice++/debug_proxy.hpp>
 #include <idevice++/ffi.hpp>
+#include <idevice++/option.hpp>
 #include <idevice++/provider.hpp>
 #include <idevice++/rsd.hpp>
 #include <idevice++/usbmuxd.hpp>
 
+using namespace IdeviceFFI;
+
+[[noreturn]]
 static void die(const char* msg, const IdeviceFFI::FfiError& e) {
     std::cerr << msg << ": " << e.message << "\n";
     std::exit(1);
@@ -21,8 +25,9 @@ static std::vector<std::string> split_args(const std::string& line) {
     std::istringstream       iss(line);
     std::vector<std::string> toks;
     std::string              tok;
-    while (iss >> tok)
+    while (iss >> tok) {
         toks.push_back(tok);
+    }
     return toks;
 }
 
@@ -30,103 +35,99 @@ int main() {
     IdeviceFFI::FfiError err;
 
     // 1) usbmuxd → pick first device
-    auto                 mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0, err);
-    if (!mux)
-        die("failed to connect to usbmuxd", err);
+    auto                 mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0);
+    if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
 
-    auto devices = mux->get_devices(err);
-    if (!devices)
-        die("failed to list devices", err);
-    if (devices->empty()) {
+    auto devices = mux.unwrap().get_devices();
+    if_let_err(devices, err, { die("failed to list devices", err); });
+    if (devices.unwrap().empty()) {
         std::cerr << "no devices connected\n";
         return 1;
     }
 
-    auto& dev  = (*devices)[0];
+    auto& dev  = (devices.unwrap())[0];
     auto  udid = dev.get_udid();
-    if (!udid) {
+    if (udid.is_none()) {
         std::cerr << "device has no UDID\n";
         return 1;
     }
     auto mux_id = dev.get_id();
-    if (!mux_id) {
+    if (mux_id.is_none()) {
         std::cerr << "device has no mux id\n";
         return 1;
     }
 
     // 2) Provider via default usbmuxd addr
-    auto              addr  = IdeviceFFI::UsbmuxdAddr::default_new();
+    auto              addr     = IdeviceFFI::UsbmuxdAddr::default_new();
 
-    const uint32_t    tag   = 0;
-    const std::string label = "debug-proxy-jkcoxson";
-    auto              provider =
-        IdeviceFFI::Provider::usbmuxd_new(std::move(addr), tag, *udid, *mux_id, label, err);
-    if (!provider)
-        die("failed to create provider", err);
+    const uint32_t    tag      = 0;
+    const std::string label    = "debug-proxy-jkcoxson";
+    auto              provider = IdeviceFFI::Provider::usbmuxd_new(
+        std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label);
+    if_let_err(provider, err, { die("failed to create provider", err); });
 
     // 3) CoreDeviceProxy
-    auto cdp = IdeviceFFI::CoreDeviceProxy::connect(*provider, err);
-    if (!cdp)
-        die("failed CoreDeviceProxy connect", err);
+    auto cdp = CoreDeviceProxy::connect(provider.unwrap())
+                   .unwrap_or_else([](FfiError e) -> CoreDeviceProxy {
+                       die("failed to connect CoreDeviceProxy", e);
+                   });
 
-    auto rsd_port = cdp->get_server_rsd_port(err);
-    if (!rsd_port)
-        die("failed to get RSD port", err);
+    auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
+        [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
 
-    // 4) Software tunnel → stream
-    auto adapter = std::move(*cdp).create_tcp_adapter(err);
-    if (!adapter)
-        die("failed to create software tunnel adapter", err);
+    // 4) Create software tunnel adapter (consumes proxy)
+    auto adapter = std::move(cdp).create_tcp_adapter();
+    if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); });
 
-    auto stream = adapter->connect(*rsd_port, err);
-    if (!stream)
-        die("failed to connect RSD stream", err);
+    // 5) Connect adapter to RSD → ReadWrite stream
+    auto stream = adapter.unwrap().connect(rsd_port);
+    if_let_err(stream, err, { die("failed to connect RSD stream", err); });
 
-    // 5) RSD handshake
-    auto rsd = IdeviceFFI::RsdHandshake::from_socket(std::move(*stream), err);
-    if (!rsd)
-        die("failed RSD handshake", err);
+    // 6) RSD handshake (consumes stream)
+    auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap()));
+    if_let_err(rsd, err, { die("failed RSD handshake", err); });
 
     // 6) DebugProxy over RSD
-    auto dbg = IdeviceFFI::DebugProxy::connect_rsd(*adapter, *rsd, err);
-    if (!dbg)
-        die("failed to connect DebugProxy", err);
+    auto dbg_res = IdeviceFFI::DebugProxy::connect_rsd(adapter.unwrap(), rsd.unwrap());
+    if_let_err(dbg_res, err, { die("failed to connect DebugProxy", err); });
+    auto& dbg = dbg_res.unwrap();
 
     std::cout << "Shell connected! Type 'exit' to quit.\n";
     for (;;) {
         std::cout << "> " << std::flush;
 
         std::string line;
-        if (!std::getline(std::cin, line))
+        if (!std::getline(std::cin, line)) {
             break;
+        }
         // trim
         auto first = line.find_first_not_of(" \t\r\n");
-        if (first == std::string::npos)
+        if (first == std::string::npos) {
             continue;
+        }
         auto last = line.find_last_not_of(" \t\r\n");
         line      = line.substr(first, last - first + 1);
 
-        if (line == "exit")
+        if (line == "exit") {
             break;
+        }
 
         // Interpret: first token = command name, rest = argv
         auto toks = split_args(line);
-        if (toks.empty())
+        if (toks.empty()) {
             continue;
+        }
 
         std::string              name = toks.front();
         std::vector<std::string> argv(toks.begin() + 1, toks.end());
 
-        auto                     res = dbg->send_command(name, argv, err);
-        if (!res && err) {
-            std::cerr << "send_command failed: " << err.message << "\n";
-            // clear error for next loop
-            err = IdeviceFFI::FfiError{};
-            continue;
-        }
-        if (res && !res->empty()) {
-            std::cout << *res << "\n";
-        }
+        auto                     res = dbg.send_command(name, argv);
+        match_result(
+            res,
+            ok_value,
+            { if_let_some(ok_value, some_value, { std::cout << some_value << "\n"; }); },
+            err_value,
+            { std::cerr << "send_command failed: " << err_value.message << "\n"; });
     }
 
     return 0;

cpp/examples/diagnosticsservice.cpp

@@ -3,7 +3,6 @@
 #include <cstdint>
 #include <fstream>
 #include <iostream>
-#include <optional>
 #include <string>
 
 #include <idevice++/bindings.hpp>
@@ -16,10 +15,12 @@
 
 using namespace IdeviceFFI;
 
-static void fail(const char* msg, const FfiError& e) {
+[[noreturn]]
+static void die(const char* msg, const FfiError& e) {
     std::cerr << msg;
-    if (e)
+    if (e) {
         std::cerr << ": " << e.message;
+    }
     std::cerr << "\n";
     std::exit(1);
 }
@@ -28,101 +29,105 @@ int main() {
     idevice_init_logger(Debug, Disabled, NULL);
     FfiError err;
 
-    // 1) usbmuxd, pick first device
-    auto     mux = UsbmuxdConnection::default_new(/*tag*/ 0, err);
-    if (!mux)
-        fail("failed to connect to usbmuxd", err);
+    // 1) usbmuxd → pick first device
+    auto     mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0);
+    if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
 
-    auto devices = mux->get_devices(err);
-    if (!devices)
-        fail("failed to list devices", err);
-    if (devices->empty()) {
+    auto devices = mux.unwrap().get_devices();
+    if_let_err(devices, err, { die("failed to list devices", err); });
+    if (devices.unwrap().empty()) {
         std::cerr << "no devices connected\n";
         return 1;
     }
 
-    auto& dev    = (*devices)[0];
-    auto  udid   = dev.get_udid();
-    auto  mux_id = dev.get_id();
-    if (!udid || !mux_id) {
-        std::cerr << "device missing udid or mux id\n";
+    auto& dev  = (devices.unwrap())[0];
+    auto  udid = dev.get_udid();
+    if (udid.is_none()) {
+        std::cerr << "device has no UDID\n";
+        return 1;
+    }
+    auto mux_id = dev.get_id();
+    if (mux_id.is_none()) {
+        std::cerr << "device has no mux id\n";
         return 1;
     }
 
     // 2) Provider via default usbmuxd addr
-    auto              addr  = UsbmuxdAddr::default_new();
+    auto              addr     = IdeviceFFI::UsbmuxdAddr::default_new();
 
-    const uint32_t    tag   = 0;
-    const std::string label = "diagnosticsservice-jkcoxson";
-    auto provider = Provider::usbmuxd_new(std::move(addr), tag, *udid, *mux_id, label, err);
-    if (!provider)
-        fail("failed to create provider", err);
+    const uint32_t    tag      = 0;
+    const std::string label    = "debug-proxy-jkcoxson";
+    auto              provider = IdeviceFFI::Provider::usbmuxd_new(
+        std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label);
+    if_let_err(provider, err, { die("failed to create provider", err); });
 
     // 3) CoreDeviceProxy
-    auto cdp = CoreDeviceProxy::connect(*provider, err);
-    if (!cdp)
-        fail("failed CoreDeviceProxy connect", err);
+    auto cdp = CoreDeviceProxy::connect(provider.unwrap())
+                   .unwrap_or_else([](FfiError e) -> CoreDeviceProxy {
+                       die("failed to connect CoreDeviceProxy", e);
+                   });
 
-    auto rsd_port = cdp->get_server_rsd_port(err);
-    if (!rsd_port)
-        fail("failed to get RSD port", err);
+    auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
+        [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
 
-    // 4) Software tunnel → connect to RSD
-    auto adapter = std::move(*cdp).create_tcp_adapter(err);
-    if (!adapter)
-        fail("failed to create software tunnel adapter", err);
+    // 4) Create software tunnel adapter (consumes proxy)
+    auto adapter = std::move(cdp).create_tcp_adapter();
+    if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); });
 
-    auto stream = adapter->connect(*rsd_port, err);
-    if (!stream)
-        fail("failed to connect RSD stream", err);
+    // 5) Connect adapter to RSD → ReadWrite stream
+    auto stream = adapter.unwrap().connect(rsd_port);
+    if_let_err(stream, err, { die("failed to connect RSD stream", err); });
 
-    // 5) RSD handshake
-    auto rsd = RsdHandshake::from_socket(std::move(*stream), err);
-    if (!rsd)
-        fail("failed RSD handshake", err);
-    // 6) Diagnostics Service over RSD
-    auto diag = DiagnosticsService::connect_rsd(*adapter, *rsd, err);
-    if (!diag)
-        fail("failed to connect DiagnosticsService", err);
+    // 6) RSD handshake (consumes stream)
+    auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap()));
+    if_let_err(rsd, err, { die("failed RSD handshake", err); });
+
+    // 6) DebugProxy over RSD
+    auto diag = DiagnosticsService::connect_rsd(adapter.unwrap(), rsd.unwrap());
+    if_let_err(diag, err, { die("failed to connect DebugProxy", err); });
 
     std::cout << "Getting sysdiagnose, this takes a while! iOS is slow...\n";
 
-    auto cap = diag->capture_sysdiagnose(/*dry_run=*/false, err);
-    if (!cap)
-        fail("capture_sysdiagnose failed", err);
+    auto cap = diag.unwrap().capture_sysdiagnose(/*dry_run=*/false);
+    if_let_err(cap, err, { die("capture_sysdiagnose failed", err); });
 
-    std::cout << "Got sysdiagnose! Saving to file: " << cap->preferred_filename << "\n";
+    std::cout << "Got sysdiagnose! Saving to file: " << cap.unwrap().preferred_filename << "\n";
 
     // 7) Stream to file with progress
-    std::ofstream out(cap->preferred_filename, std::ios::binary);
+    std::ofstream out(cap.unwrap().preferred_filename, std::ios::binary);
     if (!out) {
         std::cerr << "failed to open output file\n";
         return 1;
     }
 
     std::size_t       written = 0;
-    const std::size_t total   = cap->expected_length;
+    const std::size_t total   = cap.unwrap().expected_length;
 
     for (;;) {
-        auto chunk = cap->stream.next_chunk(err);
-        if (!chunk) {
-            if (err)
-                fail("stream error", err); // err set only on real error
-            break;                         // nullptr means end-of-stream
-        }
-        if (!chunk->empty()) {
-            out.write(reinterpret_cast<const char*>(chunk->data()),
-                      static_cast<std::streamsize>(chunk->size()));
-            if (!out) {
-                std::cerr << "write failed\n";
-                return 1;
-            }
-            written += chunk->size();
-        }
+        auto chunk = cap.unwrap().stream.next_chunk();
+        match_result(
+            chunk,
+            res,
+            {
+                if_let_some(res, chunk_res, {
+                    out.write(reinterpret_cast<const char*>(chunk_res.data()),
+                              static_cast<std::streamsize>(chunk_res.size()));
+                    if (!out) {
+                        std::cerr << "write failed\n";
+                        return 1;
+                    }
+                    written += chunk_res.size();
+                });
+                if (res.is_none()) {
+                    break;
+                }
+            },
+            err,
+            { die("stream error", err); });
         std::cout << "wrote " << written << "/" << total << " bytes\r" << std::flush;
     }
 
     out.flush();
-    std::cout << "\nDone! Saved to " << cap->preferred_filename << "\n";
+    std::cout << "\nDone! Saved to " << cap.unwrap().preferred_filename << "\n";
     return 0;
 }

cpp/examples/idevice_id.cpp

@@ -2,34 +2,31 @@
 
 #include <idevice++/usbmuxd.hpp>
 #include <iostream>
-#include <optional>
 
 int main() {
-    IdeviceFFI::FfiError                         e;
-    std::optional<IdeviceFFI::UsbmuxdConnection> u =
-        IdeviceFFI::UsbmuxdConnection::default_new(0, e);
-    if (u == std::nullopt) {
+    auto u = IdeviceFFI::UsbmuxdConnection::default_new(0);
+    if_let_err(u, e, {
         std::cerr << "failed to connect to usbmuxd";
         std::cerr << e.message;
-    }
+    });
 
-    auto devices = u->get_devices(e);
-    if (u == std::nullopt) {
+    auto devices = u.unwrap().get_devices();
+    if_let_err(devices, e, {
         std::cerr << "failed to get devices from usbmuxd";
         std::cerr << e.message;
-    }
+    });
 
-    for (IdeviceFFI::UsbmuxdDevice& d : *devices) {
+    for (IdeviceFFI::UsbmuxdDevice& d : devices.unwrap()) {
         auto udid = d.get_udid();
-        if (!udid) {
+        if (udid.is_none()) {
             std::cerr << "failed to get udid";
             continue;
         }
         auto connection_type = d.get_connection_type();
-        if (!connection_type) {
+        if (connection_type.is_none()) {
             std::cerr << "failed to get connection type";
             continue;
         }
-        std::cout << *udid << " (" << connection_type->to_string() << ")" << "\n";
+        std::cout << udid.unwrap() << " (" << connection_type.unwrap().to_string() << ")" << "\n";
     }
 }

cpp/examples/ideviceinfo.cpp

@@ -4,73 +4,80 @@
 #include <idevice++/provider.hpp>
 #include <idevice++/usbmuxd.hpp>
 #include <iostream>
-#include <optional>
 #include <plist/plist++.h>
 
 int main() {
     idevice_init_logger(Debug, Disabled, NULL);
 
-    IdeviceFFI::FfiError                         e;
-    std::optional<IdeviceFFI::UsbmuxdConnection> u =
-        IdeviceFFI::UsbmuxdConnection::default_new(0, e);
-    if (!u) {
+    auto u_res = IdeviceFFI::UsbmuxdConnection::default_new(0);
+    if_let_err(u_res, e, {
         std::cerr << "failed to connect to usbmuxd";
         std::cerr << e.message;
         return 1;
-    }
+    });
+    auto& u           = u_res.unwrap();
 
-    auto devices = u->get_devices(e);
-    if (!devices) {
+    auto  devices_res = u.get_devices();
+    if_let_err(devices_res, e, {
         std::cerr << "failed to get devices from usbmuxd";
         std::cerr << e.message;
         return 1;
-    }
-    if (devices->empty()) {
+    });
+    auto devices = std::move(devices_res).unwrap();
+
+    if (devices.empty()) {
         std::cerr << "no devices connected";
-        std::cerr << e.message;
         return 1;
     }
 
-    auto& dev  = (*devices)[0];
+    auto& dev  = (devices)[0];
 
     auto  udid = dev.get_udid();
-    if (!udid) {
+    if (udid.is_none()) {
         std::cerr << "no udid\n";
         return 1;
     }
 
     auto id = dev.get_id();
-    if (!id) {
+    if (id.is_none()) {
         std::cerr << "no id\n";
         return 1;
     }
 
-    IdeviceFFI::UsbmuxdAddr addr = IdeviceFFI::UsbmuxdAddr::default_new();
-    auto                    prov =
-        IdeviceFFI::Provider::usbmuxd_new(std::move(addr), /*tag*/ 0, *udid, *id, "reeeeeeeee", e);
-    if (!prov) {
+    IdeviceFFI::UsbmuxdAddr addr     = IdeviceFFI::UsbmuxdAddr::default_new();
+    auto                    prov_res = IdeviceFFI::Provider::usbmuxd_new(
+        std::move(addr), /*tag*/ 0, udid.unwrap(), id.unwrap(), "reeeeeeeee");
+    if_let_err(prov_res, e, {
         std::cerr << "provider failed: " << e.message << "\n";
         return 1;
-    }
+    });
+    auto& prov       = prov_res.unwrap();
 
-    auto client = IdeviceFFI::Lockdown::connect(*prov, e);
-    if (!client) {
+    auto  client_res = IdeviceFFI::Lockdown::connect(prov);
+    if_let_err(client_res, e, {
         std::cerr << "lockdown connect failed: " << e.message << "\n";
         return 1;
-    }
+    });
+    auto& client = client_res.unwrap();
 
-    auto pf = prov->get_pairing_file(e);
-    if (!pf) {
+    auto  pf     = prov.get_pairing_file();
+    if_let_err(pf, e, {
         std::cerr << "failed to get pairing file: " << e.message << "\n";
         return 1;
-    }
-    client->start_session(*pf, e);
+    });
+    client.start_session(pf.unwrap());
 
-    auto values = client->get_value(NULL, NULL, e);
-    if (!values) {
-        std::cerr << "get values failed: " << e.message << "\n";
-        return 1;
-    }
-    PList::Dictionary res = PList::Dictionary(*values);
-    std::cout << res.ToXml();
+    auto values = client.get_value(NULL, NULL);
+    match_result(
+        values,
+        ok_val,
+        {
+            PList::Dictionary res = PList::Dictionary(ok_val);
+            std::cout << res.ToXml();
+        },
+        e,
+        {
+            std::cerr << "get values failed: " << e.message << "\n";
+            return 1;
+        });
 }

cpp/examples/location_simulation.cpp

@@ -2,7 +2,6 @@
 
 #include <cstdlib>
 #include <iostream>
-#include <optional>
 #include <string>
 #include <thread>
 
@@ -17,6 +16,7 @@
 
 using namespace IdeviceFFI;
 
+[[noreturn]]
 static void die(const char* msg, const FfiError& e) {
     std::cerr << msg << ": " << e.message << "\n";
     std::exit(1);
@@ -26,8 +26,8 @@ int main(int argc, char** argv) {
     // Usage:
     //   simulate_location clear
     //   simulate_location set <lat> <lon>
-    bool                  do_clear = false;
-    std::optional<double> lat, lon;
+    bool           do_clear = false;
+    Option<double> lat, lon;
 
     if (argc == 2 && std::string(argv[1]) == "clear") {
         do_clear = true;
@@ -41,95 +41,82 @@ int main(int argc, char** argv) {
         return 2;
     }
 
-    FfiError err;
+    // 1) usbmuxd → pick first device
+    auto mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0);
+    if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
 
-    // 1) Connect to usbmuxd and pick first device
-    auto     mux = UsbmuxdConnection::default_new(/*tag*/ 0, err);
-    if (!mux)
-        die("failed to connect to usbmuxd", err);
-
-    auto devices = mux->get_devices(err);
-    if (!devices)
-        die("failed to list devices", err);
-    if (devices->empty()) {
+    auto devices = mux.unwrap().get_devices();
+    if_let_err(devices, err, { die("failed to list devices", err); });
+    if (devices.unwrap().empty()) {
         std::cerr << "no devices connected\n";
         return 1;
     }
-    auto& dev     = (*devices)[0];
 
-    auto  udidOpt = dev.get_udid();
-    if (!udidOpt) {
+    auto& dev  = (devices.unwrap())[0];
+    auto  udid = dev.get_udid();
+    if (udid.is_none()) {
         std::cerr << "device has no UDID\n";
         return 1;
     }
-    auto idOpt = dev.get_id();
-    if (!idOpt) {
+    auto mux_id = dev.get_id();
+    if (mux_id.is_none()) {
         std::cerr << "device has no mux id\n";
         return 1;
     }
 
-    // 2) Make a Provider for this device via default addr
-    auto              addr  = UsbmuxdAddr::default_new();
+    // 2) Provider via default usbmuxd addr
+    auto              addr     = IdeviceFFI::UsbmuxdAddr::default_new();
 
-    const uint32_t    tag   = 0;
-    const std::string label = "simulate_location-jkcoxson";
+    const uint32_t    tag      = 0;
+    const std::string label    = "debug-proxy-jkcoxson";
+    auto              provider = IdeviceFFI::Provider::usbmuxd_new(
+        std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label);
+    if_let_err(provider, err, { die("failed to create provider", err); });
 
-    auto provider = Provider::usbmuxd_new(std::move(addr), tag, *udidOpt, *idOpt, label, err);
-    if (!provider)
-        die("failed to create provider", err);
+    // 3) CoreDeviceProxy
+    auto cdp = CoreDeviceProxy::connect(provider.unwrap())
+                   .unwrap_or_else([](FfiError e) -> CoreDeviceProxy {
+                       die("failed to connect CoreDeviceProxy", e);
+                   });
 
-    // 3) Connect CoreDeviceProxy (borrow provider)
-    auto cdp = CoreDeviceProxy::connect(*provider, err);
-    if (!cdp)
-        die("failed to connect CoreDeviceProxy", err);
+    auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
+        [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
 
-    // 4) Read handshake’s server RSD port
-    auto rsd_port = cdp->get_server_rsd_port(err);
-    if (!rsd_port)
-        die("failed to get server RSD port", err);
+    // 4) Create software tunnel adapter (consumes proxy)
+    auto adapter = std::move(cdp).create_tcp_adapter();
+    if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); });
 
-    // 5) Create software tunnel adapter (consumes proxy)
-    auto adapter = std::move(*cdp).create_tcp_adapter(err);
-    if (!adapter)
-        die("failed to create software tunnel adapter", err);
+    // 5) Connect adapter to RSD → ReadWrite stream
+    auto stream = adapter.unwrap().connect(rsd_port);
+    if_let_err(stream, err, { die("failed to connect RSD stream", err); });
 
-    // 6) Connect adapter to RSD port → ReadWrite stream
-    auto stream = adapter->connect(*rsd_port, err);
-    if (!stream)
-        die("failed to connect RSD stream", err);
-
-    // 7) RSD handshake (consumes stream)
-    auto rsd = RsdHandshake::from_socket(std::move(*stream), err);
-    if (!rsd)
-        die("failed RSD handshake", err);
+    // 6) RSD handshake (consumes stream)
+    auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap()));
+    if_let_err(rsd, err, { die("failed RSD handshake", err); });
 
     // 8) RemoteServer over RSD (borrows adapter + handshake)
-    auto rs = RemoteServer::connect_rsd(*adapter, *rsd, err);
-    if (!rs)
-        die("failed to connect RemoteServer", err);
+    auto rs = RemoteServer::connect_rsd(adapter.unwrap(), rsd.unwrap());
+    if_let_err(rs, err, { die("failed to connect RemoteServer", err); });
 
     // 9) LocationSimulation client (borrows RemoteServer)
-    auto sim = LocationSimulation::create(*rs, err);
-    if (!sim)
-        die("failed to create LocationSimulation client", err);
+    auto sim_res = LocationSimulation::create(rs.unwrap());
+    if_let_err(sim_res, err, { die("failed to create LocationSimulation client", err); });
+    auto& sim = sim_res.unwrap();
 
     if (do_clear) {
-        if (!sim->clear(err))
-            die("clear failed", err);
+        if_let_err(sim.clear(), err, { die("clear failed", err); });
         std::cout << "Location cleared!\n";
         return 0;
     }
 
     // set path
-    if (!sim->set(*lat, *lon, err))
-        die("set failed", err);
-    std::cout << "Location set to (" << *lat << ", " << *lon << ")\n";
+    if_let_err(sim.set(lat.unwrap(), lon.unwrap()), err, { die("set failed", err); });
+    std::cout << "Location set to (" << lat.unwrap() << ", " << lon.unwrap() << ")\n";
     std::cout << "Press Ctrl-C to stop\n";
 
     // keep process alive like the Rust example
     for (;;) {
-        if (!sim->set(*lat, *lon, err))
-            die("set failed", err);
+        if_let_err(sim.set(lat.unwrap(), lon.unwrap()), err, { die("set failed", err); });
         std::this_thread::sleep_for(std::chrono::seconds(3));
     }
 }