Struct Resolver

pub struct Resolver<'elf> { /* private fields */ }

Implementations

impl<'t> Resolver<'t>

pub fn new(path: &Path, functions: bool, inlinees: bool) -> Result<Self>

pub fn into_stream_lazy_from<'a: 't, T: 'a + IntoIterator<Item = Addr<u64>>>( self, rx: UnboundedReceiver<Addr>, addrs: Option<T>, ) -> Result<impl Stream<Item = Result<Report, ObjectError>> + 't>

Example:

let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<u32>();
let resolver = Box::pin(resolver.into_stream_lazy_from(rx, None::<[_;0]>)?);

// Send addresses to resolver:
let send_addrs = tokio::spawn(async move {
	for addr in addrs {
		tx.send(addr)?;
	}
	Ok::<_, tokio::sync::mpsc::error::SendError<u32>>(())
});

// Receive reports from resolver:
while let Some(res) = resolver.next().await {
	res?.default_print(
	                   std::io::stdout(),
	                   0,
	                   cfg.flags.functions,
	                   cfg.flags.basenames,
	                   cfg.flags.ranges,
	                   cfg.flags.demangle,
	)?;
}
send_addrs.await??;

pub fn into_stream_resolve<'a: 't, T>( self, addrs: &'a [T], ) -> Result<impl Stream<Item = Result<Report, ObjectError>> + 't>

where T: Copy + Into<Addr<u64>>,

Example:

let resolver = Box::pin(resolver.into_stream_resolve(rx, &addrs)?);

// Receive reports from resolver:
while let Some(res) = resolver.next().await {
	res?.default_print(
	                   std::io::stdout(),
	                   0,
	                   cfg.flags.functions,
	                   cfg.flags.basenames,
	                   cfg.flags.ranges,
	                   cfg.flags.demangle,
	)?;
}

pub fn into_stream_lazy<'a: 't, T: 'a + IntoIterator<Item = Addr<u64>>>( self, addrs: Option<T>, ) -> Result<(UnboundedSender<Addr>, impl Stream<Item = Result<Report, ObjectError>> + 't)>