First, we need to teach our Store to inflate trees from the storage backend. As you might expect, fetch_local_tree builds the local tree, and fetch_remote_tree builds the remote tree. The trees should be complete, so don't leave out orphans, missing children, or bookmarks with invalid GUIDs or URLs. That way, Dogear has a full picture of the state of the world.

Let's assume we've stored the following records. The current time is T = 11, A was downloaded during the last sync (at T = 6), and the menu and B during this sync:

{ "id": "menu", "type": "folder", "parentid": "places", "children": ["bookmarkAAAA", "bookmarkBBBB"], "modified": 10 }
{ "id": "bookmarkAAAA", "type": "bookmark", "parentid": "menu", "modified": 5 }
{ "id": "bookmarkBBBB", "type": "bookmark", "parentid": "menu", "modified": 10 }

We can build a tree from those records like this, starting with the root:

# #![allow(unused_variables)]
#fn main() {
# extern crate dogear;
use dogear::{Item, Tree};
let mut builder = Tree::with_root(Item::root());
#}

For cases where we know the structure is valid, and the tree already contains the parent, we can use by_structure to indicate that the parent's children and child's parentid match. This is how we build the local tree on Desktop. Notice that we also set the needs_merge flag, to indicate that the menu has changes that we should merge:

# extern crate dogear;
# use dogear::{Result, Tree};
use dogear::{Guid, Item, Kind, MENU_GUID, ROOT_GUID};

# fn main() -> Result<()> {
let now_millis = 11;

# let mut builder = Tree::with_root(Item::root());
let mut menu = Item::new(MENU_GUID.clone(), Kind::Folder);
menu.age = now_millis - 10;
menu.needs_merge = true;

builder
    .item(menu)?
    .by_structure(&ROOT_GUID)?;
# Ok(())
# }

For cases where the parentid and children might disagree, we can set parents from parentid and children separately, using by_parent_guid and by_children. This is equivalent to by_structure, just slightly less efficient:

# extern crate dogear;
# use dogear::{Item, Kind, Tree, Result, MENU_GUID, ROOT_GUID};
# fn main() -> Result<()> {
# let now_millis = 11;
# let mut builder = Tree::with_root(Item::root());
# let mut menu = Item::new(MENU_GUID.clone(), Kind::Folder);
# builder.item(menu)?.by_structure(&ROOT_GUID)?;
let mut a = Item::new("bookmarkAAAA".into(), Kind::Bookmark);
a.age = now_millis - 5;

builder
    .item(a)?
    .by_parent_guid(MENU_GUID.clone())?;
builder.parent_for(&"bookmarkAAAA".into())
    .by_children(&MENU_GUID)?;
# Ok(())
# }

We can also insert an item without its parents, and set parents by parentid and children later, if they exist. This is also equivalent to the above:

# extern crate dogear;
# use dogear::{Item, Kind, Tree, Result, MENU_GUID, ROOT_GUID};
# fn main() -> Result<()> {
# let now_millis = 11;
# let mut builder = Tree::with_root(Item::root());
# let mut menu = Item::new(MENU_GUID.clone(), Kind::Folder);
# builder.item(menu)?.by_structure(&ROOT_GUID)?;
let mut b = Item::new("bookmarkBBBB".into(), Kind::Bookmark);
b.age = now_millis - 10;
b.needs_merge = true;

builder.item(b)?;
builder.parent_for(&"bookmarkBBBB".into())
    .by_parent_guid(MENU_GUID.clone())?;
builder.parent_for(&"bookmarkBBBB".into())
    .by_children(&MENU_GUID)?;
# Ok(())
# }

Finally, let's build and print out our tree!

# extern crate dogear;
# use dogear::{Item, Tree, Result};
use dogear::IntoTree;
# fn main() -> Result<()> {
# let mut builder = Tree::with_root(Item::root());
let tree = builder.into_tree()?;
println!("{}", tree);
# Ok(())
# }

And we see:

📂 root________ (Folder; Age = 0ms)
| 📂 menu________ (Folder; Age = 1ms; Unmerged)
| | 🔖 bookmarkAAAA (Bookmark; Age = 6ms)
| | 🔖 bookmarkBBBB (Bookmark; Age = 1ms; Unmerged)