Struct gimli::EntriesCursor [−] [src]

Get the entry that the cursor is currently pointing to.

Move the cursor to the next DIE in the tree in DFS order.

Upon successful movement of the cursor, return the delta traversal depth:

• If we moved down into the previous current entry's children, we get Some(1).

• If we moved to the previous current entry's sibling, we get Some(0).

• If the previous entry does not have any siblings and we move up to its parent's next sibling, then we get Some(-1). Note that if the parent doesn't have a next sibling, then it could go up to the parent's parent's next sibling and return Some(-2), etc.

If there is no next entry, then None is returned.

Here is an example that finds the first entry in a compilation unit that does not have any children.

let unit = get_some_unit();
let abbrevs = get_abbrevs_for_unit(&unit);

let mut first_entry_with_no_children = None;
let mut cursor = unit.entries(&abbrevs);

// Keep looping while the cursor is moving deeper into the DIE tree.
while let Some(delta_depth) = cursor.next_dfs() {
    // 0 means we moved to a sibling, a negative number means we went back
    // up to a parent's sibling. In either case, bail out of the loop because
    //  we aren't going deeper into the tree anymore.
    if delta_depth <= 0 {
        break;
    }

    let current = cursor.current()
        .expect("Should be at an entry")
        .expect("And we should parse the entry ok");
    first_entry_with_no_children = Some(current);
}

println!("The first entry with no children is {:?}",
         first_entry_with_no_children.unwrap());

Move the cursor to the next sibling DIE of the current one.

Returns Some when the cursor the cursor has been moved to the next sibling, None when there is no next sibling.

After returning None, the cursor is exhausted.

Here is an example that iterates over all of the direct children of the root entry:

let unit = get_some_unit();
let abbrevs = get_abbrevs_for_unit(&unit);

let mut cursor = unit.entries(&abbrevs);

// Move the cursor to the root's first child.
assert_eq!(cursor.next_dfs().unwrap(), 1);

// Iterate the root's children.
loop {
    let current = cursor.current()
        .expect("Should be at an entry")
        .expect("And we should parse the entry ok");

    println!("{:?} is a child of the root", current);

    if cursor.next_sibling().is_none() {
        break;
    }
}

Formats the value using the given formatter.

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more