layout_internal 0.1.0

Internal implementation crate for layout
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::Ident;

/// Get the ident for the `Vec` type associated with `name`
pub fn vec_name(name: impl ToTokens) -> Ident {
    Ident::new(&format!("{}Vec", name.to_token_stream()), Span::call_site())
}

/// Get the ident for the slice type associated with `name`
pub fn slice_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}Slice", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the mutable slice type associated with `name`
pub fn slice_mut_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}SliceMut", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the reference type associated with `name`
pub fn ref_name(name: impl ToTokens) -> Ident {
    Ident::new(&format!("{}Ref", name.to_token_stream()), Span::call_site())
}

/// Get the ident for the mutable reference type associated with `name`
pub fn ref_mut_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}RefMut", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the iterator type associated with `name`
pub fn iter_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}Iter", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the mutable iterator type associated with `name`
pub fn iter_mut_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}IterMut", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the pointer type associated with `name`
pub fn ptr_name(name: impl ToTokens) -> Ident {
    Ident::new(&format!("{}Ptr", name.to_token_stream()), Span::call_site())
}

/// Get the ident for the mutable pointer type associated with `name`
pub fn ptr_mut_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}PtrMut", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the drain type associated with `name`
pub fn drain_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}Drain", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the chunks iterator type associated with `name`
pub fn chunks_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}Chunks", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the mutable chunks iterator type associated with `name`
pub fn chunks_mut_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}ChunksMut", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the exact chunks iterator type associated with `name`
pub fn chunks_exact_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}ChunksExact", name.to_token_stream()),
        Span::call_site(),
    )
}

/// Get the ident for the mutable exact chunks iterator type associated with
/// `name`
pub fn chunks_exact_mut_name(name: impl ToTokens) -> Ident {
    Ident::new(
        &format!("{}ChunksExactMut", name.to_token_stream()),
        Span::call_site(),
    )
}

pub fn vec_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactVec<#inner> }
}

pub fn slice_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactSlice<'a, #inner> }
}

pub fn slice_mut_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactSliceMut<'a, #inner> }
}

pub fn ref_mut_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactRefMut<'a, #inner> }
}

pub fn ptr_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactPtr<#inner> }
}

pub fn ptr_mut_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactPtrMut<#inner> }
}

pub fn drain_name_compact(inner: &syn::Type) -> TokenStream {
    quote! { ::layout::CompactDrain<'a, #inner> }
}