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
117
118
119

//!
//! Implementation of Entity for an array.
//!

use super :: *;

/// Define a private namespace for all its items.
pub mod private
{
  use super :: *;

  impl< T, const N: usize > Instance for [ T ; N ]
  where
  EntityDescriptor< [ T ; N ] > : Entity,
  {
  type Entity = EntityDescriptor :: < Self >;
  #[ inline( always ) ]
  fn Reflect() -> Self ::Entity
  {
   EntityDescriptor :: < Self > ::new()
 }
 }

  impl< T, const N: usize > Entity for EntityDescriptor< [ T ; N ] >
  where
  T: 'static + Instance,
  {

  #[ inline( always ) ]
  fn is_container( &self ) -> bool
  {
   true
 }

  #[ inline( always ) ]
  fn len( &self ) -> usize
  {
   N
 }

  #[ inline( always ) ]
  fn type_name( &self ) -> &'static str
  {
   core ::any ::type_name :: < [ T ; N ] >()
 }

  #[ inline( always ) ]
  fn type_id( &self ) -> core ::any ::TypeId
  {
   core ::any ::TypeId ::of :: < [ T ; N ] >()
 }

  #[ inline( always ) ]
  fn elements( &self ) -> Box< dyn Iterator< Item = KeyVal > >
  {

   // qqq: write optimal implementation
  // let mut result: [ KeyVal ; N ] = [ KeyVal ::default() ; N ];
//
//       for i in 0..N
//       {
//         result[ i ] = KeyVal { key: "x", val: Box ::new( < T as Instance > ::Reflect() ) }
// }

   let result: Vec< KeyVal > = ( 0 .. N )
   .map( | k | KeyVal { key: Primitive ::usize( k ), val: Box ::new( < T as Instance > ::Reflect() ) } )
   .collect();

   Box ::new( result.into_iter() )
 }

 }

}

#[ doc( inline ) ]
#[ allow( unused_imports ) ]
pub use own :: *;

/// Own namespace of the module.
#[ allow( unused_imports ) ]
pub mod own
{
  use super :: *;
  #[ doc( inline ) ]
  pub use orphan :: *;
}

/// Orphan namespace of the module.
#[ allow( unused_imports ) ]
pub mod orphan
{
  use super :: *;
  #[ doc( inline ) ]
  pub use exposed :: *;
  // pub use private ::
  // {
  // };
}

/// Exposed namespace of the module.
#[ allow( unused_imports ) ]
pub mod exposed
{
  use super :: *;
  #[ doc( inline ) ]
  pub use prelude :: *;
}

#[ doc( inline ) ]
#[ allow( unused_imports ) ]
pub use exposed :: *;

/// Prelude to use essentials: `use my_module ::prelude :: *`.
#[ allow( unused_imports ) ]
pub mod prelude
{
  use super :: *;
}