StephenDev0/idevice
1
0
Fork 0
mirror of https://github.com/jkcoxson/idevice.git synced 2026-03-02 14:36:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove dangerous result/option macros

Browse Source
This commit is contained in:
Jackson Coxson
2025-09-03 19:48:43 -06:00
parent ca56575c6c
commit b0e3c5769a
8 changed files with 215 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
cpp/examples/app_service.cpp
View File

@@ -44,12 +44,9 @@ int main(int argc, char** argv) {
FfiError err; FfiError err;
// 1) Connect to usbmuxd and pick first device // 1) Connect to usbmuxd and pick first device
auto mux = UsbmuxdConnection::default_new(/*tag*/ 0); auto mux = UsbmuxdConnection::default_new(/*tag*/ 0).expect("failed to connect to usbmuxd");
if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
auto devices_res = mux.unwrap().get_devices(); auto devices = mux.get_devices().expect("failed to list devices");
if_let_err(devices_res, err, { die("failed to list devices", err); });
auto& devices = devices_res.unwrap();
if (devices.empty()) { if (devices.empty()) {
std::cerr << "no devices connected\n"; std::cerr << "no devices connected\n";
return 1; return 1;
@@ -73,10 +70,9 @@ int main(int argc, char** argv) {
const uint32_t tag = 0; const uint32_t tag = 0;
const std::string label = "app_service-jkcoxson"; const std::string label = "app_service-jkcoxson";
auto provider_res = auto provider =
Provider::usbmuxd_new(std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label); 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); }); .expect("failed to create provider");
auto& provider = provider_res.unwrap();
// 3) CoreDeviceProxy // 3) CoreDeviceProxy
auto cdp = CoreDeviceProxy::connect(provider).unwrap_or_else( auto cdp = CoreDeviceProxy::connect(provider).unwrap_or_else(
@@ -86,20 +82,17 @@ int main(int argc, char** argv) {
[](FfiError err) -> uint16_t { die("failed to get server RSD port", err); }); [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
// 4) Create software tunnel adapter (consumes proxy) // 4) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(cdp).create_tcp_adapter(); auto adapter =
if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); }); std::move(cdp).create_tcp_adapter().expect("failed to create software tunnel adapter");
// 5) Connect adapter to RSD → ReadWrite stream // 5) Connect adapter to RSD → ReadWrite stream
auto stream = adapter.unwrap().connect(rsd_port); auto stream = adapter.connect(rsd_port).expect("failed to connect RSD stream");
if_let_err(stream, err, { die("failed to connect RSD stream", err); });
// 6) RSD handshake (consumes stream) // 6) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap())); auto rsd = RsdHandshake::from_socket(std::move(stream)).expect("failed RSD handshake");
if_let_err(rsd, err, { die("failed RSD handshake", err); });
// 7) AppService over RSD (borrows adapter + handshake) // 7) AppService over RSD (borrows adapter + handshake)
auto app = AppService::connect_rsd(adapter.unwrap(), rsd.unwrap()) auto app = AppService::connect_rsd(adapter, rsd).unwrap_or_else([&](FfiError e) -> AppService {
.unwrap_or_else([&](FfiError e) -> AppService {
die("failed to connect AppService", e); // never returns die("failed to connect AppService", e); // never returns
}); });
@@ -160,7 +153,7 @@ int main(int argc, char** argv) {
} }
std::string bundle_id = argv[2]; std::string bundle_id = argv[2];
if_let_err(app.uninstall(bundle_id), err, { die("uninstall failed", err); }); app.uninstall(bundle_id).expect("Uninstall failed");
std::cout << "Uninstalled " << bundle_id << "\n"; std::cout << "Uninstalled " << bundle_id << "\n";
return 0; return 0;

44
cpp/examples/debug_proxy.cpp
View File

@@ -34,18 +34,16 @@ static std::vector<std::string> split_args(const std::string& line) {
int main() { int main() {
IdeviceFFI::FfiError err; IdeviceFFI::FfiError err;
// 1) usbmuxd → pick first device // 1) Connect to usbmuxd and pick first device
auto mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0); auto mux = UsbmuxdConnection::default_new(/*tag*/ 0).expect("failed to connect to usbmuxd");
if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
auto devices = mux.unwrap().get_devices(); auto devices = mux.get_devices().expect("failed to list devices");
if_let_err(devices, err, { die("failed to list devices", err); }); if (devices.empty()) {
if (devices.unwrap().empty()) {
std::cerr << "no devices connected\n"; std::cerr << "no devices connected\n";
return 1; return 1;
} }
auto& dev = (devices)[0];
auto& dev = (devices.unwrap())[0];
auto udid = dev.get_udid(); auto udid = dev.get_udid();
if (udid.is_none()) { if (udid.is_none()) {
std::cerr << "device has no UDID\n"; std::cerr << "device has no UDID\n";
@@ -58,39 +56,35 @@ int main() {
} }
// 2) Provider via default usbmuxd addr // 2) Provider via default usbmuxd addr
auto addr = IdeviceFFI::UsbmuxdAddr::default_new(); auto addr = UsbmuxdAddr::default_new();
const uint32_t tag = 0; const uint32_t tag = 0;
const std::string label = "debug-proxy-jkcoxson"; const std::string label = "app_service-jkcoxson";
auto provider = IdeviceFFI::Provider::usbmuxd_new(
std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label); auto provider =
if_let_err(provider, err, { die("failed to create provider", err); }); Provider::usbmuxd_new(std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label)
.expect("failed to create provider");
// 3) CoreDeviceProxy // 3) CoreDeviceProxy
auto cdp = CoreDeviceProxy::connect(provider.unwrap()) auto cdp = CoreDeviceProxy::connect(provider).unwrap_or_else(
.unwrap_or_else([](FfiError e) -> CoreDeviceProxy { [](FfiError e) -> CoreDeviceProxy { die("failed to connect CoreDeviceProxy", e); });
die("failed to connect CoreDeviceProxy", e);
});
auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else( auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
[](FfiError err) -> uint16_t { die("failed to get server RSD port", err); }); [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
// 4) Create software tunnel adapter (consumes proxy) // 4) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(cdp).create_tcp_adapter(); auto adapter =
if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); }); std::move(cdp).create_tcp_adapter().expect("failed to create software tunnel adapter");
// 5) Connect adapter to RSD → ReadWrite stream // 5) Connect adapter to RSD → ReadWrite stream
auto stream = adapter.unwrap().connect(rsd_port); auto stream = adapter.connect(rsd_port).expect("failed to connect RSD stream");
if_let_err(stream, err, { die("failed to connect RSD stream", err); });
// 6) RSD handshake (consumes stream) // 6) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap())); auto rsd = RsdHandshake::from_socket(std::move(stream)).expect("failed RSD handshake");
if_let_err(rsd, err, { die("failed RSD handshake", err); });
// 6) DebugProxy over RSD // 6) DebugProxy over RSD
auto dbg_res = IdeviceFFI::DebugProxy::connect_rsd(adapter.unwrap(), rsd.unwrap()); auto dbg =
if_let_err(dbg_res, err, { die("failed to connect DebugProxy", err); }); IdeviceFFI::DebugProxy::connect_rsd(adapter, rsd).expect("failed to connect DebugProxy");
auto& dbg = dbg_res.unwrap();
std::cout << "Shell connected! Type 'exit' to quit.\n"; std::cout << "Shell connected! Type 'exit' to quit.\n";
for (;;) { for (;;) {

58
cpp/examples/diagnosticsservice.cpp
View File

@@ -29,18 +29,16 @@ int main() {
idevice_init_logger(Debug, Disabled, NULL); idevice_init_logger(Debug, Disabled, NULL);
FfiError err; FfiError err;
// 1) usbmuxd → pick first device // 1) Connect to usbmuxd and pick first device
auto mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0); auto mux = UsbmuxdConnection::default_new(/*tag*/ 0).expect("failed to connect to usbmuxd");
if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
auto devices = mux.unwrap().get_devices(); auto devices = mux.get_devices().expect("failed to list devices");
if_let_err(devices, err, { die("failed to list devices", err); }); if (devices.empty()) {
if (devices.unwrap().empty()) {
std::cerr << "no devices connected\n"; std::cerr << "no devices connected\n";
return 1; return 1;
} }
auto& dev = (devices)[0];
auto& dev = (devices.unwrap())[0];
auto udid = dev.get_udid(); auto udid = dev.get_udid();
if (udid.is_none()) { if (udid.is_none()) {
std::cerr << "device has no UDID\n"; std::cerr << "device has no UDID\n";
@@ -53,58 +51,54 @@ int main() {
} }
// 2) Provider via default usbmuxd addr // 2) Provider via default usbmuxd addr
auto addr = IdeviceFFI::UsbmuxdAddr::default_new(); auto addr = UsbmuxdAddr::default_new();
const uint32_t tag = 0; const uint32_t tag = 0;
const std::string label = "debug-proxy-jkcoxson"; const std::string label = "app_service-jkcoxson";
auto provider = IdeviceFFI::Provider::usbmuxd_new(
std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label); auto provider =
if_let_err(provider, err, { die("failed to create provider", err); }); Provider::usbmuxd_new(std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label)
.expect("failed to create provider");
// 3) CoreDeviceProxy // 3) CoreDeviceProxy
auto cdp = CoreDeviceProxy::connect(provider.unwrap()) auto cdp = CoreDeviceProxy::connect(provider).unwrap_or_else(
.unwrap_or_else([](FfiError e) -> CoreDeviceProxy { [](FfiError e) -> CoreDeviceProxy { die("failed to connect CoreDeviceProxy", e); });
die("failed to connect CoreDeviceProxy", e);
});
auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else( auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
[](FfiError err) -> uint16_t { die("failed to get server RSD port", err); }); [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
// 4) Create software tunnel adapter (consumes proxy) // 4) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(cdp).create_tcp_adapter(); auto adapter =
if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); }); std::move(cdp).create_tcp_adapter().expect("failed to create software tunnel adapter");
// 5) Connect adapter to RSD → ReadWrite stream // 5) Connect adapter to RSD → ReadWrite stream
auto stream = adapter.unwrap().connect(rsd_port); auto stream = adapter.connect(rsd_port).expect("failed to connect RSD stream");
if_let_err(stream, err, { die("failed to connect RSD stream", err); });
// 6) RSD handshake (consumes stream) // 6) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap())); auto rsd = RsdHandshake::from_socket(std::move(stream)).expect("failed RSD handshake");
if_let_err(rsd, err, { die("failed RSD handshake", err); });
// 6) DebugProxy over RSD // 7) DebugProxy over RSD
auto diag = DiagnosticsService::connect_rsd(adapter.unwrap(), rsd.unwrap()); auto diag =
if_let_err(diag, err, { die("failed to connect DebugProxy", err); }); DiagnosticsService::connect_rsd(adapter, rsd).expect("failed to connect DebugProxy");
std::cout << "Getting sysdiagnose, this takes a while! iOS is slow...\n"; std::cout << "Getting sysdiagnose, this takes a while! iOS is slow...\n";
auto cap = diag.unwrap().capture_sysdiagnose(/*dry_run=*/false); auto cap = diag.capture_sysdiagnose(/*dry_run=*/false).expect("capture_sysdiagnose failed");
if_let_err(cap, err, { die("capture_sysdiagnose failed", err); });
std::cout << "Got sysdiagnose! Saving to file: " << cap.unwrap().preferred_filename << "\n"; std::cout << "Got sysdiagnose! Saving to file: " << cap.preferred_filename << "\n";
// 7) Stream to file with progress // 7) Stream to file with progress
std::ofstream out(cap.unwrap().preferred_filename, std::ios::binary); std::ofstream out(cap.preferred_filename, std::ios::binary);
if (!out) { if (!out) {
std::cerr << "failed to open output file\n"; std::cerr << "failed to open output file\n";
return 1; return 1;
} }
std::size_t written = 0; std::size_t written = 0;
const std::size_t total = cap.unwrap().expected_length; const std::size_t total = cap.expected_length;
for (;;) { for (;;) {
auto chunk = cap.unwrap().stream.next_chunk(); auto chunk = cap.stream.next_chunk();
match_result( match_result(
chunk, chunk,
res, res,
@@ -128,6 +122,6 @@ int main() {
} }
out.flush(); out.flush();
std::cout << "\nDone! Saved to " << cap.unwrap().preferred_filename << "\n"; std::cout << "\nDone! Saved to " << cap.preferred_filename << "\n";
return 0; return 0;
} }

15
cpp/examples/idevice_id.cpp
View File

@@ -4,19 +4,10 @@
#include <iostream> #include <iostream>
int main() { int main() {
auto u = IdeviceFFI::UsbmuxdConnection::default_new(0); auto u = IdeviceFFI::UsbmuxdConnection::default_new(0).expect("failed to connect to usbmuxd");
if_let_err(u, e, { auto devices = u.get_devices().expect("failed to get devices from usbmuxd");
std::cerr << "failed to connect to usbmuxd";
std::cerr << e.message;
});
auto devices = u.unwrap().get_devices(); for (IdeviceFFI::UsbmuxdDevice& d : devices) {
if_let_err(devices, e, {
std::cerr << "failed to get devices from usbmuxd";
std::cerr << e.message;
});
for (IdeviceFFI::UsbmuxdDevice& d : devices.unwrap()) {
auto udid = d.get_udid(); auto udid = d.get_udid();
if (udid.is_none()) { if (udid.is_none()) {
std::cerr << "failed to get udid"; std::cerr << "failed to get udid";

41
cpp/examples/ideviceinfo.cpp
View File

@@ -9,21 +9,9 @@
int main() { int main() {
idevice_init_logger(Debug, Disabled, NULL); idevice_init_logger(Debug, Disabled, NULL);
auto u_res = IdeviceFFI::UsbmuxdConnection::default_new(0); auto u = IdeviceFFI::UsbmuxdConnection::default_new(0).expect("failed to connect to usbmuxd");
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_res = u.get_devices(); auto devices = u.get_devices().expect("failed to get devices from usbmuxd");
if_let_err(devices_res, e, {
std::cerr << "failed to get devices from usbmuxd";
std::cerr << e.message;
return 1;
});
auto devices = std::move(devices_res).unwrap();
if (devices.empty()) { if (devices.empty()) {
std::cerr << "no devices connected"; std::cerr << "no devices connected";
@@ -45,27 +33,14 @@ int main() {
} }
IdeviceFFI::UsbmuxdAddr addr = IdeviceFFI::UsbmuxdAddr::default_new(); IdeviceFFI::UsbmuxdAddr addr = IdeviceFFI::UsbmuxdAddr::default_new();
auto prov_res = IdeviceFFI::Provider::usbmuxd_new( auto prov = IdeviceFFI::Provider::usbmuxd_new(
std::move(addr), /*tag*/ 0, udid.unwrap(), id.unwrap(), "reeeeeeeee"); std::move(addr), /*tag*/ 0, udid.unwrap(), id.unwrap(), "reeeeeeeee")
if_let_err(prov_res, e, { .expect("Failed to create usbmuxd provider");
std::cerr << "provider failed: " << e.message << "\n";
return 1;
});
auto& prov = prov_res.unwrap();
auto client_res = IdeviceFFI::Lockdown::connect(prov); auto client = IdeviceFFI::Lockdown::connect(prov).expect("lockdown connect failed");
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(); auto pf = prov.get_pairing_file().expect("failed to get pairing file");
if_let_err(pf, e, { client.start_session(pf).expect("failed to start session");
std::cerr << "failed to get pairing file: " << e.message << "\n";
return 1;
});
client.start_session(pf.unwrap());
auto values = client.get_value(NULL, NULL); auto values = client.get_value(NULL, NULL);
match_result( match_result(

52
cpp/examples/location_simulation.cpp
View File

@@ -41,18 +41,16 @@ int main(int argc, char** argv) {
return 2; return 2;
} }
// 1) usbmuxd → pick first device // 1) Connect to usbmuxd and pick first device
auto mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0); auto mux = UsbmuxdConnection::default_new(/*tag*/ 0).expect("failed to connect to usbmuxd");
if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
auto devices = mux.unwrap().get_devices(); auto devices = mux.get_devices().expect("failed to list devices");
if_let_err(devices, err, { die("failed to list devices", err); }); if (devices.empty()) {
if (devices.unwrap().empty()) {
std::cerr << "no devices connected\n"; std::cerr << "no devices connected\n";
return 1; return 1;
} }
auto& dev = (devices)[0];
auto& dev = (devices.unwrap())[0];
auto udid = dev.get_udid(); auto udid = dev.get_udid();
if (udid.is_none()) { if (udid.is_none()) {
std::cerr << "device has no UDID\n"; std::cerr << "device has no UDID\n";
@@ -65,58 +63,52 @@ int main(int argc, char** argv) {
} }
// 2) Provider via default usbmuxd addr // 2) Provider via default usbmuxd addr
auto addr = IdeviceFFI::UsbmuxdAddr::default_new(); auto addr = UsbmuxdAddr::default_new();
const uint32_t tag = 0; const uint32_t tag = 0;
const std::string label = "debug-proxy-jkcoxson"; const std::string label = "app_service-jkcoxson";
auto provider = IdeviceFFI::Provider::usbmuxd_new(
std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label); auto provider =
if_let_err(provider, err, { die("failed to create provider", err); }); Provider::usbmuxd_new(std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label)
.expect("failed to create provider");
// 3) CoreDeviceProxy // 3) CoreDeviceProxy
auto cdp = CoreDeviceProxy::connect(provider.unwrap()) auto cdp = CoreDeviceProxy::connect(provider).unwrap_or_else(
.unwrap_or_else([](FfiError e) -> CoreDeviceProxy { [](FfiError e) -> CoreDeviceProxy { die("failed to connect CoreDeviceProxy", e); });
die("failed to connect CoreDeviceProxy", e);
});
auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else( auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
[](FfiError err) -> uint16_t { die("failed to get server RSD port", err); }); [](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
// 4) Create software tunnel adapter (consumes proxy) // 4) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(cdp).create_tcp_adapter(); auto adapter =
if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); }); std::move(cdp).create_tcp_adapter().expect("failed to create software tunnel adapter");
// 5) Connect adapter to RSD → ReadWrite stream // 5) Connect adapter to RSD → ReadWrite stream
auto stream = adapter.unwrap().connect(rsd_port); auto stream = adapter.connect(rsd_port).expect("failed to connect RSD stream");
if_let_err(stream, err, { die("failed to connect RSD stream", err); });
// 6) RSD handshake (consumes stream) // 6) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap())); auto rsd = RsdHandshake::from_socket(std::move(stream)).expect("failed RSD handshake");
if_let_err(rsd, err, { die("failed RSD handshake", err); });
// 8) RemoteServer over RSD (borrows adapter + handshake) // 8) RemoteServer over RSD (borrows adapter + handshake)
auto rs = RemoteServer::connect_rsd(adapter.unwrap(), rsd.unwrap()); auto rs = RemoteServer::connect_rsd(adapter, rsd).expect("failed to connect to RemoteServer");
if_let_err(rs, err, { die("failed to connect RemoteServer", err); });
// 9) LocationSimulation client (borrows RemoteServer) // 9) LocationSimulation client (borrows RemoteServer)
auto sim_res = LocationSimulation::create(rs.unwrap()); auto sim = LocationSimulation::create(rs).expect("failed to create LocationSimulation client");
if_let_err(sim_res, err, { die("failed to create LocationSimulation client", err); });
auto& sim = sim_res.unwrap();
if (do_clear) { if (do_clear) {
if_let_err(sim.clear(), err, { die("clear failed", err); }); sim.clear().expect("clear failed");
std::cout << "Location cleared!\n"; std::cout << "Location cleared!\n";
return 0; return 0;
} }
// set path // set path
if_let_err(sim.set(lat.unwrap(), lon.unwrap()), err, { die("set failed", err); }); sim.set(lat.unwrap(), lon.unwrap()).expect("set failed");
std::cout << "Location set to (" << lat.unwrap() << ", " << lon.unwrap() << ")\n"; std::cout << "Location set to (" << lat.unwrap() << ", " << lon.unwrap() << ")\n";
std::cout << "Press Ctrl-C to stop\n"; std::cout << "Press Ctrl-C to stop\n";
// keep process alive like the Rust example // keep process alive like the Rust example
for (;;) { for (;;) {
if_let_err(sim.set(lat.unwrap(), lon.unwrap()), err, { die("set failed", err); }); sim.set(lat.unwrap(), lon.unwrap()).expect("set failed");
std::this_thread::sleep_for(std::chrono::seconds(3)); std::this_thread::sleep_for(std::chrono::seconds(3));
} }
} }

48
cpp/include/idevice++/option.hpp
View File

@@ -8,7 +8,6 @@
#pragma once #pragma once
#include <cstdio>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
@@ -106,6 +105,8 @@ template <typename T> class Option {
// unwrap_or / unwrap_or_else // unwrap_or / unwrap_or_else
T unwrap_or(T default_value) const& { return has_ ? *ptr() : std::move(default_value); } T unwrap_or(T default_value) const& { return has_ ? *ptr() : std::move(default_value); }
T unwrap_or(T default_value) && { return has_ ? std::move(*ptr()) : std::move(default_value); } T unwrap_or(T default_value) && { return has_ ? std::move(*ptr()) : std::move(default_value); }
T unwrap_or(const T& default_value) const& { return has_ ? *ptr() : default_value; }
T unwrap_or(T&& default_value) const& { return has_ ? *ptr() : std::move(default_value); }
template <typename F> T unwrap_or_else(F&& f) const& { template <typename F> T unwrap_or_else(F&& f) const& {
return has_ ? *ptr() : static_cast<T>(f()); return has_ ? *ptr() : static_cast<T>(f());
@@ -123,6 +124,16 @@ template <typename T> class Option {
} }
return Option<U>(None); return Option<U>(None);
} }
template <typename F>
auto map(F&& f) && -> Option<typename std::decay<decltype(f(std::move(*ptr())))>::type> {
using U = typename std::decay<decltype(f(std::move(*ptr())))>::type;
if (has_) {
// Move the value into the function
return Option<U>(f(std::move(*ptr())));
}
return Option<U>(None);
}
}; };
// Helpers // Helpers
@@ -131,21 +142,17 @@ template <typename T> inline Option<typename std::decay<T>::type> Some(T&& v) {
} }
inline Option<void> Some() = delete; // no Option<void> inline Option<void> Some() = delete; // no Option<void>
// template <typename T> inline Option<T> None() { #define match_option(opt, some_name, some_block, none_block) \
// return Option<T>(none); /* NOTE: you may return in a block, but not break/continue */ \
// } // still needs T specified do { \
auto&& _option_val = (opt); \
// Prefer this at call sites (lets return-type drive the type): if (_option_val.is_some()) { \
// return none; auto&& some_name = _option_val.unwrap(); \
some_block \
#define match_option(opt, SOME, NONE) \ } else { \
if ((opt).is_some()) { \ none_block \
auto&& SOME = (opt).unwrap();
#define or_else \
} \ } \
else { \ } while (0)
NONE; \
}
// --- Option helpers: if_let_some / if_let_some_move / if_let_none --- // --- Option helpers: if_let_some / if_let_some_move / if_let_none ---
@@ -154,6 +161,7 @@ inline Option<void> Some() = delete; // no Option<void>
/* Bind a reference to the contained value if Some(...) */ /* Bind a reference to the contained value if Some(...) */
#define if_let_some(expr, name, block) \ #define if_let_some(expr, name, block) \
/* NOTE: you may return in a block, but not break/continue */ \
do { \ do { \
auto _opt_unique(_opt_) = (expr); \ auto _opt_unique(_opt_) = (expr); \
if (_opt_unique(_opt_).is_some()) { \ if (_opt_unique(_opt_).is_some()) { \
@@ -164,6 +172,7 @@ inline Option<void> Some() = delete; // no Option<void>
/* Move the contained value out (consumes the Option) if Some(...) */ /* Move the contained value out (consumes the Option) if Some(...) */
#define if_let_some_move(expr, name, block) \ #define if_let_some_move(expr, name, block) \
/* NOTE: you may return in a block, but not break/continue */ \
do { \ do { \
auto _opt_unique(_opt_) = (expr); \ auto _opt_unique(_opt_) = (expr); \
if (_opt_unique(_opt_).is_some()) { \ if (_opt_unique(_opt_).is_some()) { \
@@ -172,13 +181,4 @@ inline Option<void> Some() = delete; // no Option<void>
} \ } \
} while (0) } while (0)
/* Run a block if the option is None */
#define if_let_none(expr, block) \
do { \
auto _opt_unique(_opt_) = (expr); \
if (_opt_unique(_opt_).is_none()) { \
block \
} \
} while (0)
} // namespace IdeviceFFI } // namespace IdeviceFFI

107
cpp/include/idevice++/result.hpp
View File

@@ -76,6 +76,57 @@ template <typename T, typename E> class Result {
} }
} }
// Copy Assignment
Result& operator=(const Result& other) {
// Prevent self-assignment
if (this == &other) {
return *this;
}
// Destroy the current value
if (is_ok_) {
ok_value_.~T();
} else {
err_value_.~E();
}
is_ok_ = other.is_ok_;
// Construct the new value
if (is_ok_) {
new (&ok_value_) T(other.ok_value_);
} else {
new (&err_value_) E(other.err_value_);
}
return *this;
}
// Move Assignment
Result& operator=(Result&& other) noexcept {
if (this == &other) {
return *this;
}
// Destroy the current value
if (is_ok_) {
ok_value_.~T();
} else {
err_value_.~E();
}
is_ok_ = other.is_ok_;
// Construct the new value by moving
if (is_ok_) {
new (&ok_value_) T(std::move(other.ok_value_));
} else {
new (&err_value_) E(std::move(other.err_value_));
}
return *this;
}
bool is_ok() const { return is_ok_; } bool is_ok() const { return is_ok_; }
bool is_err() const { return !is_ok_; } bool is_err() const { return !is_ok_; }
@@ -132,6 +183,32 @@ template <typename T, typename E> class Result {
T unwrap_or(T&& default_value) const { return is_ok_ ? ok_value_ : std::move(default_value); } T unwrap_or(T&& default_value) const { return is_ok_ ? ok_value_ : std::move(default_value); }
T expect(const char* message) && {
if (is_err()) {
std::fprintf(stderr, "Fatal (expect) error: %s\n", message);
std::terminate();
}
return std::move(ok_value_);
}
// Returns a mutable reference from an lvalue Result
T& expect(const char* message) & {
if (is_err()) {
std::fprintf(stderr, "Fatal (expect) error: %s\n", message);
std::terminate();
}
return ok_value_;
}
// Returns a const reference from a const lvalue Result
const T& expect(const char* message) const& {
if (is_err()) {
std::fprintf(stderr, "Fatal (expect) error: %s\n", message);
std::terminate();
}
return ok_value_;
}
template <typename F> T unwrap_or_else(F&& f) & { template <typename F> T unwrap_or_else(F&& f) & {
return is_ok_ ? ok_value_ : static_cast<T>(f(err_value_)); return is_ok_ ? ok_value_ : static_cast<T>(f(err_value_));
} }
@@ -206,26 +283,24 @@ template <typename E> class Result<void, E> {
} }
return err_value_; return err_value_;
} }
void expect(const char* message) const {
if (is_err()) {
std::fprintf(stderr, "Fatal (expect) error: %s\n", message);
std::terminate();
}
}
}; };
#define match_result(res, ok_name, ok_block, err_name, err_block) \ #define match_result(res, ok_name, ok_block, err_name, err_block) \
if ((res).is_ok()) { \ do { \
auto&& ok_name = (res).unwrap(); \ auto&& _result_val = (res); \
if (_result_val.is_ok()) { \
auto&& ok_name = _result_val.unwrap(); \
ok_block \ ok_block \
} else { \ } else { \
auto&& err_name = (res).unwrap_err(); \ auto&& err_name = _result_val.unwrap_err(); \
err_block \ err_block \
} } \
} while (0)
#define if_let_err(res, name, block) \
if ((res).is_err()) { \
auto&& name = (res).unwrap_err(); \
block \
}
#define if_let_ok(res, name, block) \
if ((res).is_ok()) { \
auto&& name = (res).unwrap(); \
block \
}
} // namespace IdeviceFFI } // namespace IdeviceFFI