ic-stable-memory-derive 0.4.2

Derive macros for ic-stable-memory
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

use crate::as_fixed_size_bytes::derive_as_fixed_size_bytes_impl;
use crate::candid_as_dyn_size_bytes::derive_candid_as_dyn_size_bytes_impl;
use crate::fixed_size_as_dyn_size_bytes::derive_fixed_size_as_dyn_size_bytes_impl;
use crate::stable_type::derive_stable_type_impl;
use proc_macro::TokenStream as Tokens;
use proc_macro2::{self, TokenStream};
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Fields, Ident, Index};

mod as_fixed_size_bytes;
mod candid_as_dyn_size_bytes;
mod fixed_size_as_dyn_size_bytes;
mod stable_type;

/// Derives [ic_stable_memory::StableType] proxying flag toggling calls
#[proc_macro_derive(StableType)]
pub fn derive_stable_type(input: Tokens) -> Tokens {
    let DeriveInput {
        ident,
        data,
        generics,
        ..
    } = parse_macro_input!(input);

    derive_stable_type_impl(&ident, &data, &generics).into()
}

/// Derives [ic_stable_memory::AsFixedSizeBytes]. Does not support generics at the moment.
#[proc_macro_derive(AsFixedSizeBytes)]
pub fn derive_as_fixed_size_bytes(input: Tokens) -> Tokens {
    let DeriveInput {
        ident,
        data,
        generics,
        ..
    } = parse_macro_input!(input);

    derive_as_fixed_size_bytes_impl(&ident, &data, &generics).into()
}

/// Derives [ic_stable_memory::AsDynSizeBytes] for a type that already implements [candid::CandidType] and [candid::Deserialize].
#[proc_macro_derive(CandidAsDynSizeBytes)]
pub fn derive_candid_as_dyn_size_bytes(input: Tokens) -> Tokens {
    let DeriveInput {
        ident, generics, ..
    } = parse_macro_input!(input);

    derive_candid_as_dyn_size_bytes_impl(&ident, &generics).into()
}

/// Derives [ic_stable_memory::AsDynSizeBytes] for a type that already implements [ic_stable_memory::AsFixedSizeBytes].
#[proc_macro_derive(FixedSizeAsDynSizeBytes)]
pub fn derive_fixed_size_as_dyn_size_bytes(input: Tokens) -> Tokens {
    let DeriveInput {
        ident, generics, ..
    } = parse_macro_input!(input);

    derive_fixed_size_as_dyn_size_bytes_impl(&ident, &generics).into()
}