thread_aware 0.7.0

Facilities to support thread-isolated state.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

#![expect(missing_docs, reason = "This is a test module")]
#![allow(dead_code, unused_variables, unused_assignments, reason = "compile-only derive test")]

use thread_aware::ThreadAware;
use thread_aware::affinity::pinned_affinities;

#[derive(ThreadAware)]
struct Simple {
    a: i32,
    b: Option<String>,
}

#[derive(ThreadAware)]
struct Tuple(i64, #[thread_aware(skip)] i64);

#[derive(ThreadAware)]
enum E {
    A,
    B(i32, i32),
    C {
        x: i32,
        #[thread_aware(skip)]
        y: i32,
    },
}

// adapter test removed (no 'with' support currently)

#[test]
fn derive_compiles_and_runs() {
    let affinities = pinned_affinities(&[2]);
    let d0 = Some(affinities[0]);
    let d1 = affinities[1];

    let mut s = Simple {
        a: 10,
        b: Some("x".to_string()),
    };
    thread_aware::ThreadAware::relocate(&mut s, d0, d1);

    let mut t = Tuple(5, 6);
    thread_aware::ThreadAware::relocate(&mut t, d0, d1);
    assert_eq!(t.0, 5);
    assert_eq!(t.1, 6);

    let mut e = E::C { x: 1, y: 2 };
    thread_aware::ThreadAware::relocate(&mut e, d0, d1);

    // removed adapter test; basic derive coverage above is sufficient
}