format_tools 0.6.0

Collection of mechanisms for formatting and serialization into string.
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()
//   }
// }