command_history 1.1.0

A library for managing command history in Rust applications.
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

# Command History Library


## Overview


This library provides a command history mechanism for managing and executing commands with undo and redo capabilities. It includes various modules and traits to facilitate the implementation of command patterns in Rust.

## Features


- **Simple Command History**: A straightforward implementation of command history with undo and redo functionality.
- **Concurrent Command History**: A thread-safe version of command history using `Arc` and `Mutex`.
- **Shared Context**: A utility for managing shared state across commands.
- **Traits**: Defines the necessary traits for commands and command histories.

## Modules


### `concurrent_command_history`

Provides a thread-safe implementation of command history.

### `shared_context`

Defines a shared context structure that can be used across multiple commands.

### `simple_command_history`

Implements a basic command history with undo and redo capabilities.

### `traits`

Contains the traits required for commands and command histories:
- `command`
- `command_history`
- `mutable_command`
- `mutable_command_history`

## Usage


Add the following to your `Cargo.toml` to include the `command_history` library from crates.io:

```toml
[dependencies]
command_history = "1.0.0"
```

Then, you can use the library in your project as follows:

```rust
use command_history::prelude::*;

// Your command implementation and usage here
```

### Example


```rust
use command_history::prelude::*;

struct MyCommand {
    // Command implementation
}

impl MutableCommand for MyCommand {
    // Implement required methods
}

fn main() {
    let mut history = SimpleCommandHistory::new(10, true);
    let mut ctx = RefCell::new(0);

    let command = MyCommand { /* fields */ };
    history.execute_command(command, &mut ctx);

    // Undo and redo operations
    history.undo_command(&mut ctx);
    history.redo_command(&mut ctx);
}
```

## Testing


The library includes comprehensive tests for all modules. To run the tests, use:

```sh
cargo test
```

## License


This project is licensed under either of:
- MIT license
- Apache License, Version 2.0

## Contributing


Contributions are welcome! Please open an issue or submit a pull request on GitHub.