checkpoint

Provides checkpointing of application data for the Rust Programming Language.

Please see the API documentation for details.

Example Usage: ```rust // Checkpoint data is serialized and deserialized with the Serde library. extern crate serde;

[macrouse] extern crate serdederive;

use serde::de::DeserializeOwned; use serde::ser::Serialize;

extern crate checkpoint;

use checkpoint::Result; use checkpoint::storage::{ CommittedCheckpoint, Storage, MemoryStorage, UncommittedCheckpoint}; use checkpoint::wrappers::ChecksumWrapper;

// Any type implementing the Serialize and DeserializeOwned traits can be checkpointed.

[derive(Deserialize, Serialize)]

struct Person { name: String, age: u8 }

// Create the data that will be stored in a checkpoint. let person = Person { name: String::from("John Smith"), age: 50 };

// Create a MemoryStorage object to hold checkpoint data. let storage = MemoryStorage::new()?;

// Add integrity checks to checkpoint data with a ChecksumWrapper. let mut wrapped_storage = ChecksumWrapper::wrap(storage);

// Create a new checkpoint. let mut uncommittedcheckpoint = wrappedstorage.create_checkpoint("Checkpoint")?;

// Add data to the checkpoint. uncommitted_checkpoint.put("Person", &person)?;

// Commit the checkpoint. let mut committedcheckpoint = wrappedstorage.commitcheckpoint(uncommittedcheckpoint)?;

// Retrieve the checkpoint data. let storedperson: Person = committedcheckpoint.get("Person")?;

// The data retrieved from the checkpoint is the same as what was put in. asserteq!(person.name, storedperson.name); asserteq!(person.age, storedperson.age); ```