Crate track

This library offers a boilerplate free approach to track struct data modifications. For optimization, only the adjusted fields are tracked. Changes will be serialized and sent on an channel.

Examples

First, add track attribute to mark your struct as trackable.

// imports all necessarily types for the `track` attribute.
use track::preclude::*;

#[track]
#[derive(Debug)]
pub struct Position {
    pub x: u32,
    pub y: u32,
}

You can specify a serialization method for the track macro. Give the name of the type that implements SerializationStrategy, and make sure it is in scope for the macro. Such as:

use track::serialization::bincode::Bincode;

#[track(serialization = "Bincode")]
struct Postition ...

Now let us make some modifications and apply those to other instances.

use track::{preclude::*, serialization::bincode::Bincode, Apply, ModificationChannel};

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Identity {
    pub value: u8,
}

impl Identifier for Identity {}

fn main() {
    let channel = ModificationChannel::<Identity>::new();

    let updated_storage = vec![
        (Identity { value: 1 }, Position { x: 0, y: 0 }),
        (Identity { value: 2 }, Position { x: 0, y: 0 }),
    ];
    let mut outdated_storage = updated_storage.clone();

    // == Make changes to storage ==
    make_changes(&channel, updated_storage);

    // == Apply changes to outdated storage ==
    apply_changes(&channel, &mut outdated_storage);
}

fn make_changes(channel: &ModificationChannel<Identity>, entities: Vec<(Identity, Position)>) {
    for (id, mut position) in entities {
        let mut position = position.track(channel.sender(), id); /* returns `Tracker` which tracks changes */

        // `Tracker` implements `DerefMut`
        position.x += 1;
        position.y += 1;
    } // <- on the `Drop` of `wrapper` changes are serialized and sent on the channel.
}

fn apply_changes(
    channel: &ModificationChannel<Identity>,
    entities: &mut Vec<(Identity, Position)>,
) {
    for event in channel.receiver().try_iter() {
        let entity = entities
            .iter_mut()
            .find(|e| e.0 == event.identifier)
            .unwrap();

        Apply::apply_to(&mut entity.1, &event.modified_fields, Bincode);

        println!("entity updated {:?}", entity);
    }
}

For a more in-depth example checkout the examples on github.

Modules

error
preclude	A re-export with types needed for the track attribute.
re_exports
serialization	Module with different serializers that can be used with this crate.

Structs

Apply	Applies modified values to a type.
ModificationChannel	An event channel over which modification events are sent.
ModificationEvent	A modification event.
Tracker	Tracks value modifications of a type and sends events with these changes.

Traits

Identifier	A marker trait witch should be implemented for types used as identity in the Tracker.
Trackable	A trait with functions for tracking struct value modifications.
TrackableMarker	A marker trait with a number of requirements that are mandatory for trackable types.

Attribute Macros

track

A macro attribute that indicates a type that needs to be tracked and implements Trackable and TrackableMarker.