graphrecords-core 0.5.0

High-performance graph-based data records
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::{GraphRecord, errors::GraphRecordResult};
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::ops::{Deref, DerefMut};

pub trait Connector {
    fn initialize(&self, graphrecord: &mut GraphRecord) -> GraphRecordResult<()>;
    fn disconnect(&self, graphrecord: &mut GraphRecord) -> GraphRecordResult<()>;
}

pub trait IngestConnector: Connector {
    type DataSet;

    fn ingest(&self, graphrecord: &mut GraphRecord, data: Self::DataSet) -> GraphRecordResult<()>;
}

pub trait ExportConnector: Connector {
    type DataSet;

    fn export(&self, graphrecord: &GraphRecord) -> GraphRecordResult<Self::DataSet>;
}

impl GraphRecord {
    pub fn with_connector<C: Connector>(
        connector: C,
    ) -> GraphRecordResult<ConnectedGraphRecord<C>> {
        ConnectedGraphRecord::new(connector)
    }

    pub fn from_connector_with_data<D, C: IngestConnector<DataSet = D>>(
        connector: C,
        data: D,
    ) -> GraphRecordResult<ConnectedGraphRecord<C>> {
        ConnectedGraphRecord::from_connector_with_data(connector, data)
    }
}

#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct ConnectedGraphRecord<C: Connector> {
    graphrecord: GraphRecord,
    connector: C,
}

impl<C: Connector> Deref for ConnectedGraphRecord<C> {
    type Target = GraphRecord;

    fn deref(&self) -> &Self::Target {
        &self.graphrecord
    }
}

impl<C: Connector> DerefMut for ConnectedGraphRecord<C> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.graphrecord
    }
}

impl<C: Connector> AsRef<GraphRecord> for ConnectedGraphRecord<C> {
    fn as_ref(&self) -> &GraphRecord {
        &self.graphrecord
    }
}

impl<C: Connector> AsMut<GraphRecord> for ConnectedGraphRecord<C> {
    fn as_mut(&mut self) -> &mut GraphRecord {
        &mut self.graphrecord
    }
}

impl<C: Connector> From<ConnectedGraphRecord<C>> for GraphRecord {
    fn from(connected: ConnectedGraphRecord<C>) -> Self {
        connected.graphrecord
    }
}

impl<C: Connector> ConnectedGraphRecord<C> {
    pub fn new(connector: C) -> GraphRecordResult<Self> {
        let mut graphrecord = GraphRecord::new();

        connector.initialize(&mut graphrecord)?;

        Ok(Self {
            graphrecord,
            connector,
        })
    }

    pub fn from_connector_with_data<D>(connector: C, data: D) -> GraphRecordResult<Self>
    where
        C: IngestConnector<DataSet = D>,
    {
        let mut graphrecord = GraphRecord::new();

        connector.initialize(&mut graphrecord)?;

        connector.ingest(&mut graphrecord, data)?;

        Ok(Self {
            graphrecord,
            connector,
        })
    }

    pub fn disconnect(mut self) -> GraphRecordResult<GraphRecord> {
        self.connector.disconnect(&mut self.graphrecord)?;

        Ok(self.graphrecord)
    }
}

impl<C: IngestConnector> ConnectedGraphRecord<C> {
    pub fn ingest(&mut self, data: C::DataSet) -> GraphRecordResult<()> {
        self.connector.ingest(&mut self.graphrecord, data)
    }
}

impl<C: ExportConnector> ConnectedGraphRecord<C> {
    pub fn export(&self) -> GraphRecordResult<C::DataSet> {
        self.connector.export(&self.graphrecord)
    }
}