| 1 | use super::*; |
|---|---|
| 2 | |
| 3 | impl Writer { |
| 4 | pub fn write_core(&self) -> TokenStream { |
| 5 | if self.config.sys { |
| 6 | if self.config.package || !self.config.no_core { |
| 7 | quote! { windows_sys::core:: } |
| 8 | } else if self.config.flat { |
| 9 | quote! {} |
| 10 | } else { |
| 11 | let mut tokens = TokenStream::new(); |
| 12 | |
| 13 | for _ in 0..self.namespace.split('.').count() { |
| 14 | tokens.push_str("super::"); |
| 15 | } |
| 16 | |
| 17 | tokens |
| 18 | } |
| 19 | } else { |
| 20 | quote! { windows_core:: } |
| 21 | } |
| 22 | } |
| 23 | |
| 24 | pub fn write_generic_phantoms(&self, generics: &[Type]) -> TokenStream { |
| 25 | if generics.is_empty() { |
| 26 | quote! {} |
| 27 | } else { |
| 28 | let generics = generics.iter().map(|ty| ty.write_name(self)); |
| 29 | quote! { #(core::marker::PhantomData::<#generics>),* } |
| 30 | } |
| 31 | } |
| 32 | |
| 33 | pub fn write_generic_named_phantoms(&self, generics: &[Type]) -> TokenStream { |
| 34 | if generics.is_empty() { |
| 35 | quote! {} |
| 36 | } else { |
| 37 | let generics = generics.iter().map(|ty| ty.write_name(self)); |
| 38 | quote! { #(#generics: core::marker::PhantomData::<#generics>),* } |
| 39 | } |
| 40 | } |
| 41 | |
| 42 | pub fn write_generic_constraints(&self, generics: &[Type]) -> TokenStream { |
| 43 | if generics.is_empty() { |
| 44 | quote! {} |
| 45 | } else { |
| 46 | let generics = generics.iter().map(|ty| ty.write_name(self)); |
| 47 | quote! { #(#generics: windows_core::RuntimeType + 'static,)* } |
| 48 | } |
| 49 | } |
| 50 | |
| 51 | pub fn write_namespace(&self, type_name: TypeName) -> TokenStream { |
| 52 | let mut tokens = TokenStream::new(); |
| 53 | |
| 54 | if type_name.namespace().is_empty() { |
| 55 | return tokens; |
| 56 | } |
| 57 | |
| 58 | if let Some(reference) = { |
| 59 | if self.config.types.contains_key(&type_name) { |
| 60 | None |
| 61 | } else { |
| 62 | self.config.references.contains(type_name) |
| 63 | } |
| 64 | } { |
| 65 | tokens.push_str(&reference.name); |
| 66 | tokens.push_str("::"); |
| 67 | |
| 68 | if reference.style == ReferenceStyle::Flat { |
| 69 | return tokens; |
| 70 | } |
| 71 | |
| 72 | let mut namespace = type_name.namespace().split('.').peekable(); |
| 73 | |
| 74 | if reference.style == ReferenceStyle::SkipRoot { |
| 75 | namespace.next(); |
| 76 | } |
| 77 | |
| 78 | for namespace in namespace { |
| 79 | tokens.push_str(namespace); |
| 80 | tokens.push_str("::"); |
| 81 | } |
| 82 | |
| 83 | tokens |
| 84 | } else { |
| 85 | if self.config.flat || type_name.namespace() == self.namespace { |
| 86 | return tokens; |
| 87 | } |
| 88 | |
| 89 | let mut relative = self.namespace.split('.').peekable(); |
| 90 | let mut namespace = type_name.namespace().split('.').peekable(); |
| 91 | |
| 92 | while relative.peek() == namespace.peek() { |
| 93 | if relative.next().is_none() { |
| 94 | break; |
| 95 | } |
| 96 | |
| 97 | namespace.next(); |
| 98 | } |
| 99 | |
| 100 | for _ in 0..relative.count() { |
| 101 | tokens.push_str("super::"); |
| 102 | } |
| 103 | |
| 104 | for namespace in namespace { |
| 105 | tokens.push_str(namespace); |
| 106 | tokens.push_str("::"); |
| 107 | } |
| 108 | |
| 109 | tokens |
| 110 | } |
| 111 | } |
| 112 | } |
| 113 |