Crate dodo 

Dodo

Dodo (pronounced doe doe) is a very basic persistence library designed to be a quick and easy way to create a persistent storage. It uses Serde under the hood to perform serialization of the persisted data.

Getting Started

First, create a struct implementing the Entity, Serialize and Deserialize traits, which can be done using derives. For the Entity derive to work, it must contain a field named id of type Option<Uuid>.

#[derive(Entity, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Person {
    id: Option<Uuid>,
    name: String,
    age: u64,
}

Then, create a storage for your data. You can implement your own, or use the default Directory storage.

let directory = Directory::new(path)?;

Now, you must choose a serializer. You can also implement your own, or use the default JsonSerializer. When this is done, it is highly recommanded to create a type definition for your collection using the chosen storage and serializer.

type PersonCollection = Collection<Person, Directory, JsonSerializer>;

Finally, create a collection and start using it.

let mut collection = PersonCollection::new(directory);
let mut person = Person { id: None, name: "John Smith".into(), age: 42 };
collection.insert(&mut person)?;

Example

This short example demonstrate how to use Dodo to read and write entities to the disk.

use std::error::Error;

use serde::{Deserialize, Serialize};
use uuid::Uuid;

use dodo::prelude::*;

#[derive(Debug, Entity, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Person {
    id: Option<Uuid>,
    name: String,
    age: u64,
}

type PersonCollection = Collection<Person, Directory, JsonSerializer>;

fn main() -> Result<(), Box<dyn Error>> {
    let path = tempfile::tempdir()?;

    let mut person1 = Person { id: None, name: "John Smith".into(), age: 18 };
    let mut person2 = Person { id: None, name: "Mary Smith".into(), age: 42 };

    let mut collection = PersonCollection::new(Directory::new(&path)?);
    collection.insert(&mut person1)?;
    collection.insert(&mut person2)?;

    println!("{:?}", collection.find_all()?.filter(|person| person.age > 20).collect()?);

    Ok(())
}

Re-exports

pub use serializer::JsonSerializer;

pub use storage::Directory;

Modules

collection

Collection of entities.

index

Index of values.

prelude

Prelude. Re-exports most used structs and traits.

serializer

Serializers.

storage

Storage backends.

Structs

Collection

Collection of entities, backed by provided storage.

CollectionError

Collection error.

Index

Index of values.

IndexError

Index error.

Memory

Memory storage.

Enums

CollectionErrorKind

Collection error kind.

IndexErrorKind

Index error kind.

Traits

Cursor

Cursor over the contents of a collection.

Entity

Entity.

Serializer

Serialize and deserialize data into writer and readers respectively.

Storage

Bytes storage backend.

Derive Macros

Entity

Implements the Entity trait for your struct. It must contain a field named id of type Option<Uuid>.