must_destroy 0.2.1

simple forced explcit destructors
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

# must_destroy


Must destroy is used to create a paramterized destructor for a type
that must be explicitly called.

`MustDestroy<T, Args>` acts as a guard for a wrapped type that implements the `Destroy`
trait, that causes a `panic` if the guard is dropped.

However, calling destroy upon the guard, will call destroy on wrapped child, and will
be consumed safely.

```rust
use must_destroy::{MustDestroy, Destroy};
    struct MyDestroyableItem;

    impl Destroy<(&'_ str, i32)> for MyDestroyableItem {
        fn destroy(self, args: (&str, i32)) {
            // Do things to destroy item
            assert_eq!("Test String", args.0);
            assert_eq!(12, args.1);
        }
    }

    fn main() {
        let destroy_me = MustDestroy::new(MyDestroyableItem);

        // Dropping the item here would cause a panic at runtime
        // drop(destroy_me)

        // However calling destroy will consume the item, and not cause
        // a panic.
        destroy_me.destroy("Test String", 12);
    }
```