ankurah-core 0.8.1

Core state management functionality for Ankurah
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

use std::{
    marker::PhantomData,
    sync::{Arc, Weak},
};

use crate::{
    entity::Entity,
    property::{
        backend::{pn_counter::PNValue, PNBackend},
        traits::{FromActiveType, FromEntity, InitializeWith, PropertyError},
        PropertyName,
    },
};

#[derive(Debug)]
pub struct PNCounter<I>
where I: Into<PNValue> + From<PNValue> + Copy + Clone
{
    pub property_name: PropertyName,
    pub backend: Weak<PNBackend>,
    phantom: PhantomData<I>,
}

// Starting with basic string type operations
impl<I> PNCounter<I>
where I: Into<PNValue> + From<PNValue> + Copy + Clone
{
    pub fn new(property_name: PropertyName, backend: Arc<PNBackend>) -> Self {
        Self { property_name, backend: Arc::downgrade(&backend), phantom: PhantomData }
    }
    pub fn backend(&self) -> Arc<PNBackend> { self.backend.upgrade().expect("Expected `PN` property backend to exist") }
    pub fn add(&self, amount: impl Into<PNValue>) { self.backend().add(self.property_name.clone(), amount.as_i64()); }
}

impl<I: From<PNValue>> PNCounter<I>
where I: Into<PNValue> + From<PNValue> + Copy + Clone
{
    pub fn value(&self) -> I {
        let pn_value = self.backend().get(self.property_name.clone());
        I::from(pn_value)
    }
}

impl<I> FromEntity for PNCounter<I>
where I: Into<PNValue> + From<PNValue> + Copy + Clone
{
    fn from_entity(property_name: PropertyName, entity: &Entity) -> Self {
        let backend = entity.get_backend::<PNBackend>().expect("PNBackend should exist");
        Self::new(property_name, backend)
    }
}

impl<I> FromActiveType<PNCounter<I>> for I
where I: Into<PNValue> + From<PNValue> + Copy + Clone
{
    fn from_active(active: PNCounter<I>) -> Result<Self, PropertyError>
    where Self: Sized {
        Ok(active.value())
    }
}

impl<I> InitializeWith<I> for PNCounter<I>
where I: Into<PNValue> + From<PNValue> + Copy + Clone
{
    fn initialize_with(entity: &Entity, property_name: PropertyName, value: &I) -> Self {
        let new = Self::from_entity(property_name, entity);
        new.add(*value);
        new
    }
}