Struct fog_pack::checklist::Checklist

pub struct Checklist<T> { /* fields omitted */ }

A Checklist for validating an Entry.

The checklist can be iterated over, yielding a series of hashes and their associated ChecklistItem. Passing an item to a schema along with the document referred to by the hash allows it to be checked off the list. When all items have been checked off, calling complete will return the contained data. This may be a Vec from encoding an Entry, an Entry that was decoded, or nothihng if the purpose was purely validation.

Examples

Assuming there is a HashMap containing all documents, a function to encode and verify an entry could be:

fn encode_entry(e: Entry, schema: &mut Schema, db: &HashMap<Hash, Document>) -> 
    Result<Vec<u8>, ()>
{
    let mut checklist = schema.encode_entry(e).or(Err(()))?;
    // Fetch each document for verification, and fail if we don't have one
    for (h, item) in checklist.iter_mut() {
        if let Some(doc) = db.get(h) {
            schema.check_item(doc, item);
        }
        else {
            return Err(());
        }
    }
    checklist.complete()
}

Implementations

impl<T> Checklist<T>

pub fn is_complete(&self) -> bool

Check to see if the checklist is ready for completion.

pub fn complete(self) -> Result<T, ()>

Complete the checklist and return the encoded Entry as a byte vector. Fails if the checklist was not completed.

pub fn iter(&self) -> Iter<Hash, ChecklistItem>

Iterate over the checklist, yielding tuples of type (&Hash, &ChecklistItem).

pub fn iter_mut(&mut self) -> IterMut<Hash, ChecklistItem>

Mutably iterate over the checklist, yielding tuples of type (&Hash, &mut ChecklistItem).

pub fn get(&self, h: &Hash) -> Option<&ChecklistItem>

Fetch a specific checklist item by hash.

pub fn get_mut(&mut self, h: &Hash) -> Option<&mut ChecklistItem>

Mutably fetch a specific checklist item by hash.