unbase 0.0.2

Unbase intends to be a causal, coordination-free distributed data-persistence and application framework. It is fundamentally reactive, fault tolerant, and decentralized.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use subject::{Subject, SubjectId, SubjectType};
use context::Context;
use memorefhead::MemoRefHead;
use slab::*;
use error::*;
use std::fmt;
use std::collections::HashMap;
use futures::{Stream};

#[derive(Clone)]
pub struct SubjectHandle {
    pub id: SubjectId,
    pub (crate) subject: Subject,
    pub (crate) context: Context
}

impl SubjectHandle{
    pub fn new ( context: &Context, vals: HashMap<String, String> ) -> Result<SubjectHandle,WriteError> {

        let subject = Subject::new(&context, SubjectType::Record, vals )?;

        let handle = SubjectHandle{
            id: subject.id,
            subject: subject,
            context: context.clone()
        };

        Ok(handle)
    }
    pub fn new_blank ( context: &Context ) -> Result<SubjectHandle,WriteError> {
        Self::new( context, HashMap::new() )
    }
    pub fn new_kv ( context: &Context, key: &str, value: &str ) -> Result<SubjectHandle,WriteError> {
        let mut vals = HashMap::new();
        vals.insert(key.to_string(), value.to_string());

        Self::new( context, vals )
    }
    pub fn get_value ( &self, key: &str ) -> Option<String> {
        self.subject.get_value(&self.context, key).expect("Retrieval error. TODO: Convert to Result<..,RetrieveError>")
    }
    pub fn get_relation ( &self, key: RelationSlotId ) -> Result<Option<SubjectHandle>, RetrieveError> {

        match self.subject.get_relation(&self.context, key)?{
        Some(rel_sub_subject) => {
            Ok(Some(SubjectHandle{
                id: rel_sub_subject.id,
                context: self.context.clone(),
                subject: rel_sub_subject
            }))
            },
            None => Ok(None)
        }
    }
    pub fn set_value (&self, key: &str, value: &str) -> Result<bool,WriteError> {
        self.subject.set_value(&self.context, key, value)
    }
    pub fn set_relation (&self, key: RelationSlotId, relation: &Self) -> Result<(),WriteError> {
        self.subject.set_relation(&self.context, key, &relation.subject)
    }
    pub fn head_memo_ids (&self) -> Vec<MemoId> {
        self.subject.get_head().memo_ids()
    }
    pub fn get_all_memo_ids ( &self ) -> Vec<MemoId> {
        self.subject.get_all_memo_ids(&self.context.slab)
    }
    pub fn observe (&self) -> Box<Stream<Item = MemoRefHead, Error = ()>> {
        self.subject.observe(&self.context.slab)
    }
}


impl fmt::Debug for SubjectHandle {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("Subject")
            .field("subject_id", &self.subject.id)
            .field("head", &self.subject.head)
            .finish()
    }
}