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

//! Representation of the actual data.

use semver::Version;

/// A Model is a representation of data.
///
/// A model (as you probably guessed) models data. Specifically, a Model implementation describes:
///     1. Describes what the data will look like (structure, types, etcetera)
///     2. The model's name
///     3. The model's version
///
/// Actual instances of implementations will hold the data.
///
/// ## Describing the data
///
/// Describing the data structure is easy: add fields to the struct implementing the model.
pub trait Model {
    /// The name of the model.
    /// Each type of model has a name (not to be confused with a model instance's key), this is the
    /// used by the PersistenceEngine to determine which Persister to use when storing or retrieving
    /// the model.
    ///
    /// While not required, it is recommended that the name of the model be the same as the name of
    /// the implementing type, but in kebab-case instead of PascalCase.
    fn model_name() -> &'static str;

    /// Each model implementation has a version. When the structure of that model changes, the
    /// version also needs to change. As of right now, the model implementation must handle
    /// converting from an older version to a newer version when deserializing from bytes.
    ///
    /// You may notice that this is defined on a `Self` level and not a `self` level. This is
    /// because all loaded models of a single type should have the same version, and that version
    /// should not change without changes in the code as well.
    fn model_version() -> &'static Version;

    /// Gets the key for the model instance. As you can probably guess, the key uniquely identifies
    /// a model instance (as opposed to the `model_name` which uniquely identifies a model type).
    fn get_key(&self) -> &str;
}

/// A representation of a stored [model](Model). While every [model](Model) type has it's own
/// version when loaded, the same cannot be said before they're loaded, or while they're in the
/// process of being loaded. This acts as representation of that.
#[derive(Debug)]
pub struct StoredModel<M: Model> {
    pub version: Version,
    pub model: M,
}

impl<M: Model> From<(Version, M)> for StoredModel<M> {
    fn from((version, model): (Version, M)) -> Self {
        Self { version, model }
    }
}