shared-struct 0.1.1

Proc-macro for turning a struct into a shared concurrent wrapper
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

# shared-struct

A procedural macro that transforms a struct into a shared, cheaply-cloneable wrapper with per-field fine-grained locking. Each field gets its own `tokio::sync::Mutex`, so concurrent access to different fields does not block. The wrapper itself is an `Arc` — cloning is cheap and all clones share the same data.

## Usage

```rust
use shared_macro::shared;

#[shared]
pub struct Context {
    pub name: String,
    pub count: u32,
    #[raw]
    pub tag: String,
}
```

### What gets generated

```
ContextInner              — inner struct with per-field locks
Context(Arc<ContextInner>)
```

## Field attributes

| Attribute | Storage | Accessor |
|-----------|---------|----------|
| *(default)* | `Mutex<T>` | `async fn field(&self) -> MutexGuard<T>` |
| `#[raw]` | `T` (no lock) | `fn field(&self) -> &T` |

## Clone semantics

`clone()` is `Arc::clone` — all clones share the same data.

```rust
let ctx = Context::new("hello".to_string(), 0, "t".to_string());
let ctx2 = ctx.clone();

*ctx.name().await = "world".to_string();
assert_eq!(*ctx2.name().await, "world"); // same Arc
```

## Visibility

Field visibility is preserved on `ContextInner` and all accessors.

```rust
#[shared]
pub struct Foo {
    pub public_field: String,
    pub(crate) crate_field: u32,
    private_field: bool,
}
```

## Dependencies

Runtime crate requires `tokio` with the `sync` feature.