[][src]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.


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

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

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
            .find(|e| e.0 == event.identifier)

        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.



A re-export with types needed for the track attribute.


Module with different serializers that can be used with this crate.



Applies modified values to a type.


An event channel over which modification events are sent.


A modification event.


Tracks value modifications of a type and sends events with these changes.



A marker trait witch should be implemented for types used as identity in the Tracker.


A trait with functions for tracking struct value modifications.


A marker trait with a number of requirements that are mandatory for trackable types.

Attribute Macros


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