hoomd-derive 1.1.0

Derive macros for hoomd-rs traits.
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// Copyright (c) 2024-2026 The Regents of the University of Michigan.
// Part of hoomd-rs, released under the BSD 3-Clause License.

//! Implement the derive(MaximumInteractionRange) macro

use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::{Data, DeriveInput, Fields, Index, parse_quote, spanned::Spanned};

/// Implement the derive(MaximumInteractionRange) macro.
pub(crate) fn maximum_interaction_range(input: DeriveInput) -> TokenStream {
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    let name = &input.ident;

    let data = match input.data {
        Data::Struct(data) => data,
        Data::Enum(_) | Data::Union(_) => {
            return quote_spanned! {
                name.span() =>
                compile_error!("derive(MaximumInteractionRange) applies only to struct types.");
            };
        }
    };

    if has_maximum_interaction_range(&data.fields) {
        quote! {
            impl #impl_generics ::hoomd_interaction::MaximumInteractionRange for #name #ty_generics #where_clause {
                #[inline]
                fn maximum_interaction_range(&self) -> f64 {
                    self.maximum_interaction_range
                }
            }
        }
    } else {
        let max = maximum_interaction_range_max(&data.fields);

        let mut generics = input.generics.clone();
        let field_types = data.fields.iter().map(|f| f.ty.clone());
        if let Some(previous_where_clause) = generics.where_clause {
            let predicates = previous_where_clause.predicates;
            generics.where_clause = Some(parse_quote!(where
            #predicates,
            #(#field_types: ::hoomd_interaction::MaximumInteractionRange),*
            ));
        } else {
            generics.where_clause = Some(parse_quote!(where
                #(#field_types: ::hoomd_interaction::MaximumInteractionRange),*));
        }
        let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

        quote! {
            impl #impl_generics ::hoomd_interaction::MaximumInteractionRange for #name #ty_generics #where_clause {
                #[inline]
                fn maximum_interaction_range(&self) -> f64 {
                    #max
                }
            }
        }
    }
}

/// Determine if there exists a field named `maximum_interaction_range`.
fn has_maximum_interaction_range(fields: &Fields) -> bool {
    for field in fields {
        if let Some(ref ident) = field.ident
            && ident == "maximum_interaction_range"
        {
            return true;
        }
    }
    false
}

/// Get the maximum interaction range from all terms in the Hamiltonian.
fn maximum_interaction_range_max(fields: &Fields) -> TokenStream {
    match fields {
        Fields::Named(fields) => {
            let terms = fields.named.iter().map(|f| {
                let name = &f.ident;
                quote_spanned! {f.span()=>
                    ::hoomd_interaction::MaximumInteractionRange::maximum_interaction_range(&self.#name)
                }
            });

            quote! {
                let mut total = 0.0_f64;
                #(total = total.max(#terms);)*
                total
            }
        }
        Fields::Unnamed(fields) => {
            let terms = fields.unnamed.iter().enumerate().map(|(i, f)| {
                let index = Index::from(i);
                quote_spanned! {f.span()=>
                    ::hoomd_interaction::MaximumInteractionRange::maximum_interaction_range(&self.#index)
                }
            });

            quote! {
                let mut total = 0.0_f64;
                #(total = total.max(#terms);)*
                total
            }
        }
        Fields::Unit => {
            quote!(0.0_f64)
        }
    }
}