# Struct backtrace::Backtrace [−] [src]

    pub struct Backtrace { /* fields omitted */ }

Representation of an owned and self-contained backtrace.

This structure can be used to capture a backtrace at various points in a program and later used to inspect what the backtrace was at that time.

## Methods

### `impl Backtrace`
[src]

#### `pub fn new() -> Backtrace`
[src]

Captures a backtrace at the callsite of this function, returning an owned representation.

This function is useful for representing a backtrace as an object in Rust. This returned value can be sent across threads and printed elsewhere, and the purpose of this value is to be entirely self contained.

# Examples

    use backtrace::Backtrace;

    let current_backtrace = Backtrace::new();

#### `pub fn new_unresolved() -> Backtrace`
[src]

Similar to `new` except that this does not resolve any symbols, this simply captures the backtrace as a list of addresses.

At a later time the `resolve` function can be called to resolve this backtrace's symbols into readable names. This function exists because the resolution process can sometimes take a significant amount of time whereas any one backtrace may only be rarely printed.

# Examples

    use backtrace::Backtrace;

    let mut current_backtrace = Backtrace::new_unresolved();
    println!("{:?}", current_backtrace); // no symbol names
    current_backtrace.resolve();
    println!("{:?}", current_backtrace); // symbol names now present

#### `pub fn frames(&self) -> &[BacktraceFrame]`
[src]

Returns the frames from when this backtrace was captured.

The first entry of this slice is likely the function `Backtrace::new`, and the last frame is likely something about how this thread or the main function started.

#### `pub fn resolve(&mut self)`
[src]

If this backtrace was created from `new_unresolved` then this function will resolve all addresses in the backtrace to their symbolic names.

If this backtrace has been previously resolved or was created through `new`, this function does nothing.

## Trait Implementations

### `impl Clone for Backtrace`
[src]

#### `fn clone(&self) -> Backtrace`
[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`
1.0.0
[src]

Performs copy-assignment from `source`. Read more

### `impl From<Vec<BacktraceFrame>> for Backtrace`
[src]

#### `fn from(frames: Vec<BacktraceFrame>) -> Self`
[src]

Performs the conversion.

### `impl Into<Vec<BacktraceFrame>> for Backtrace`
[src]

#### `fn into(self) -> Vec<BacktraceFrame>`
[src]

Performs the conversion.

### `impl Debug for Backtrace`
[src]

#### `fn fmt(&self, fmt: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter. Read more

### `impl Default for Backtrace`
[src]

#### `fn default() -> Backtrace`
[src]

Returns the "default value" for a type. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)