reflect_tools 0.8.0

Collection of mechanisms for reflection.
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

//!
//! It's often necessary to wrap something inot a local structure and this file contains a resusable local structure for wrapping.
//!

// use core ::fmt;
use core ::ops :: { Deref };

/// Converter into universal wrapper with transparent option of copy on write reference emphasizing a specific aspect of identity of its internal type.
pub trait IntoRef< 'a, T, Marker >
{
  /// Converter into universal wrapper with transparent option of copy on write reference emphasizing a specific aspect of identity of its internal type.
  fn into_ref( self ) -> Ref< 'a, T, Marker >;
}

impl< 'a, T, Marker > IntoRef< 'a, T, Marker > for &'a T
{
  #[ inline( always ) ]
  fn into_ref( self ) -> Ref< 'a, T, Marker >
  {
  Ref :: < 'a, T, Marker > ::new( self )
 }
}

/// Transparent reference wrapper emphasizing a specific aspect of identity of its internal type.
#[ allow( missing_debug_implementations ) ]
#[ repr( transparent ) ]
pub struct Ref< 'a, T, Marker >( pub &'a T, ::core ::marker ::PhantomData< fn() -> Marker > )
where
  ::core ::marker ::PhantomData< fn( Marker ) > : Copy,
  &'a T: Copy,
;

impl< 'a, T, Marker > Clone for Ref< 'a, T, Marker >
{
  #[ inline( always ) ]
  fn clone( &self ) -> Self
  {
  Self ::new( self.0 )
 }
}

impl< 'a, T, Marker > Copy for Ref< 'a, T, Marker > {}

impl< 'a, T, Marker > Ref< 'a, T, Marker >
{

  /// Just a constructor.
  #[ inline( always ) ]
  pub fn new( src: &'a T ) -> Self
  {
  Self( src, ::core ::marker ::PhantomData )
 }

  /// Just a constructor.
  #[ inline( always ) ]
  pub fn inner( self ) -> &'a T
  {
  self.0
 }

}

impl< 'a, T, Marker > AsRef< T > for Ref< 'a, T, Marker >
{
  fn as_ref( &self ) -> &T
  {
  &self.0
 }
}

impl< 'a, T, Marker > Deref for Ref< 'a, T, Marker >
{
  type Target = T;
  fn deref( &self ) -> &Self ::Target
  {
  &self.0
 }
}

impl< 'a, T, Marker > From< &'a T > for Ref< 'a, T, Marker >
{
  fn from( src: &'a T ) -> Self
  {
  Ref ::new( src )
 }
}

// impl< 'a, T, Marker > From< Ref< 'a, T, Marker > > for &'a T
// {
//   fn from( wrapper: Ref< 'a, T, Marker > ) -> &'a T
//   {
//     wrapper.0
// }
// }

// impl< 'a, T, Marker > Default for Ref< 'a, T, Marker >
// where
//   T: Default,
// {
//   fn default() -> Self
//   {
//     Ref( &T ::default() )
// }
// }

// impl< 'a, T, Marker > fmt ::Debug for Ref< 'a, T, Marker >
// where
//   T: fmt ::Debug,
// {
//   fn fmt( &self, f: &mut fmt ::Formatter< '_ > ) -> fmt ::Result
//   {
//     f.debug_struct( "Ref" )
//     .field( "0", &self.0 )
//     .finish()
// }
// }