macro_tools 0.85.0

Tools for writing procedural macroses.
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

//!
//! A generic optional boolean attribute property: `Option<  bool  >`.
//! Defaults to `false`.
//!
use core ::marker ::PhantomData;

use crate :: *;
use components ::Assign;

/// Default marker for `AttributePropertyOptionalSingletone`.
/// Used if no marker is defined as parameter.
#[ derive( Debug, Default, Clone, Copy ) ]
pub struct AttributePropertyOptionalBooleanMarker;

/// A generic optional boolean attribute property: `Option<  bool  >`.
/// Defaults to `false`.
#[ derive( Debug, Default, Clone, Copy ) ]
pub struct AttributePropertyOptionalBoolean< Marker = AttributePropertyOptionalBooleanMarker >(
  Option< bool >,
  ::core ::marker ::PhantomData< Marker >,
);

impl< Marker > AttributePropertyOptionalBoolean< Marker > 
{
  /// Just unwraps and returns the internal data.
  #[ must_use ]
  #[ inline( always ) ]
  pub fn internal(self) -> Option< bool >
  {
  self.0
 }

  /// Returns a reference to the internal optional boolean value.
  #[ must_use ]
  #[ inline( always ) ]
  pub fn ref_internal( &self ) -> Option< &bool >
  {
  self.0.as_ref()
 }
}

impl< Marker, IntoT > Assign< AttributePropertyOptionalBoolean<Marker >, IntoT> for AttributePropertyOptionalBoolean< Marker >
where
  IntoT: Into< AttributePropertyOptionalBoolean<Marker >>,
{
  /// Inserts value of another instance into the option if it is None, then returns a mutable reference to the contained value.
  /// If another instance does is None then do nothing.
  #[ inline( always ) ]
  #[ allow( clippy ::single_match ) ]
  fn assign(&mut self, component: IntoT) 
  {
  let component = component.into();
  match component.0 
  {
   Some(val) =>
  {
  self.0 = Some(val);
 }
   None => {}
 }
 }
}

impl< Marker > AttributePropertyComponent for AttributePropertyOptionalBoolean< Marker >
where
  Marker: AttributePropertyComponent,
{
  const KEYWORD: &'static str = Marker ::KEYWORD;
}

impl< Marker > syn ::parse ::Parse for AttributePropertyOptionalBoolean< Marker > 
{
  fn parse(input: syn ::parse ::ParseStream< '_ >) -> syn ::Result< Self > 
  {
  input.parse :: < syn ::Token![ = ] >()?;
  let value: syn ::LitBool = input.parse()?;
  Ok(value.value.into())
 }
}

impl< Marker > From< bool > for AttributePropertyOptionalBoolean< Marker > 
{
  #[ inline( always ) ]
  #[ allow( clippy ::default_constructed_unit_structs ) ]
  fn from(src: bool) -> Self 
  {
  Self(Some(src), PhantomData ::default())
 }
}

impl< Marker > From< Option< bool >> for AttributePropertyOptionalBoolean< Marker > 
{
  #[ inline( always ) ]
  #[ allow( clippy ::default_constructed_unit_structs ) ]
  fn from(src: Option< bool >) -> Self 
  {
  Self(src, PhantomData ::default())
 }
}

impl< Marker > From< AttributePropertyOptionalBoolean<Marker >> for Option< bool > 
{
  #[ inline( always ) ]
  fn from(src: AttributePropertyOptionalBoolean< Marker >) -> Self 
  {
  src.0
 }
}

impl< Marker > core ::ops ::Deref for AttributePropertyOptionalBoolean< Marker > 
{
  type Target = Option< bool >;
  #[ inline( always ) ]
  fn deref( &self ) -> &Option< bool > 
  {
  &self.0
 }
}

impl< Marker > AsRef< Option< bool >> for AttributePropertyOptionalBoolean< Marker > 
{
  #[ inline( always ) ]
  fn as_ref( &self ) -> &Option< bool > 
  {
  &self.0
 }
}