1  // Copyright (c) 2019-2025 Alpha-Delta Network Inc.
 2  // This file is part of the alphavm library.
 3  
 4  // Licensed under the Apache License, Version 2.0 (the "License");
 5  // you may not use this file except in compliance with the License.
 6  // You may obtain a copy of the License at:
 7  
 8  // http://www.apache.org/licenses/LICENSE-2.0
 9  
10  // Unless required by applicable law or agreed to in writing, software
11  // distributed under the License is distributed on an "AS IS" BASIS,
12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  // See the License for the specific language governing permissions and
14  // limitations under the License.
15  
16  use super::*;
17  
18  impl<N: Network> FromBytes for Access<N> {
19      /// Reads the access from a buffer.
20      fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
21          let variant = u8::read_le(&mut reader)?;
22          match variant {
23              0 => Ok(Self::Member(Identifier::read_le(&mut reader)?)),
24              1 => Ok(Self::Index(U32::read_le(&mut reader)?)),
25              2.. => Err(error(format!("Failed to deserialize access variant {variant}"))),
26          }
27      }
28  }
29  
30  impl<N: Network> ToBytes for Access<N> {
31      /// Write the access to a buffer.
32      fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
33          match self {
34              Access::Member(identifier) => {
35                  0u8.write_le(&mut writer)?;
36                  identifier.write_le(&mut writer)
37              }
38              Access::Index(index) => {
39                  1u8.write_le(&mut writer)?;
40                  index.write_le(&mut writer)
41              }
42          }
43      }
44  }
45  
46  #[cfg(test)]
47  mod tests {
48      use super::*;
49      use crate::data::identifier::tests::sample_identifier;
50      use alphavm_console_network::MainnetV0;
51  
52      type CurrentNetwork = MainnetV0;
53  
54      const ITERATIONS: u32 = 1000;
55  
56      fn check_bytes(expected: Access<CurrentNetwork>) -> Result<()> {
57          // Check the byte representation.
58          let expected_bytes = expected.to_bytes_le()?;
59          assert_eq!(expected, Access::read_le(&expected_bytes[..])?);
60          Ok(())
61      }
62  
63      #[test]
64      fn test_bytes() -> Result<()> {
65          let rng = &mut TestRng::default();
66  
67          for _ in 0..ITERATIONS {
68              // Member
69              let identifier = sample_identifier(rng)?;
70              check_bytes(Access::Member(identifier))?;
71  
72              // Index
73              let index = U32::<CurrentNetwork>::rand(rng);
74              check_bytes(Access::Index(index))?;
75          }
76          Ok(())
77      }
78  }