light-zero-copy 0.7.0

Zero copy vector and utils for Solana programs.
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
128
129
130

use core::{convert::Infallible, fmt};
#[cfg(feature = "std")]
use std::error::Error;

#[derive(Debug, PartialEq)]
pub enum ZeroCopyError {
    Full,
    ArraySize(usize, usize),
    IterFromOutOfBounds,
    InsufficientMemoryAllocated(usize, usize),
    UnalignedPointer,
    MemoryNotZeroed,
    InvalidConversion,
    InvalidData(Infallible),
    Size,
    InvalidOptionByte(u8),
    InvalidCapacity,
    LengthGreaterThanCapacity,
    CurrentIndexGreaterThanLength,
    InvalidEnumValue,
    InsufficientCapacity,
    PlatformSizeOverflow,
}

impl fmt::Display for ZeroCopyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ZeroCopyError::Full => write!(f, "The vector is full, cannot push any new elements"),
            ZeroCopyError::ArraySize(expected, actual) => write!(
                f,
                "Requested array of size {}, but the vector has {} elements",
                expected, actual
            ),
            ZeroCopyError::IterFromOutOfBounds => {
                write!(f, "The requested start index is out of bounds")
            }
            ZeroCopyError::InsufficientMemoryAllocated(allocated, required) => write!(
                f,
                "Memory allocated {}, Memory required {}",
                allocated, required
            ),
            ZeroCopyError::UnalignedPointer => write!(f, "Unaligned pointer"),
            ZeroCopyError::MemoryNotZeroed => write!(f, "Memory not zeroed"),
            ZeroCopyError::InvalidConversion => write!(f, "Invalid conversion"),
            ZeroCopyError::InvalidData(_) => write!(f, "Invalid data"),
            ZeroCopyError::Size => write!(f, "Invalid size"),
            ZeroCopyError::InvalidOptionByte(byte) => write!(
                f,
                "Invalid option byte {} must be 0 (None) or 1 (Some)",
                byte
            ),
            ZeroCopyError::InvalidCapacity => {
                write!(f, "Invalid capacity. Capacity must be greater than 0")
            }
            ZeroCopyError::LengthGreaterThanCapacity => {
                write!(f, "Length is greater than capacity")
            }
            ZeroCopyError::CurrentIndexGreaterThanLength => {
                write!(f, "Current index is greater than length")
            }
            ZeroCopyError::InvalidEnumValue => write!(f, "Invalid enum value"),
            ZeroCopyError::InsufficientCapacity => write!(f, "Insufficient capacity for operation"),
            ZeroCopyError::PlatformSizeOverflow => write!(f, "Value too large for platform usize"),
        }
    }
}

#[cfg(feature = "std")]
impl Error for ZeroCopyError {}

impl From<ZeroCopyError> for u32 {
    fn from(e: ZeroCopyError) -> u32 {
        match e {
            ZeroCopyError::Full => 15001,
            ZeroCopyError::ArraySize(_, _) => 15002,
            ZeroCopyError::IterFromOutOfBounds => 15003,
            ZeroCopyError::InsufficientMemoryAllocated(_, _) => 15004,
            ZeroCopyError::UnalignedPointer => 15006,
            ZeroCopyError::MemoryNotZeroed => 15007,
            ZeroCopyError::InvalidConversion => 15008,
            ZeroCopyError::InvalidData(_) => 15009,
            ZeroCopyError::Size => 15010,
            ZeroCopyError::InvalidOptionByte(_) => 15011,
            ZeroCopyError::InvalidCapacity => 15012,
            ZeroCopyError::LengthGreaterThanCapacity => 15013,
            ZeroCopyError::CurrentIndexGreaterThanLength => 15014,
            ZeroCopyError::InvalidEnumValue => 15015,
            ZeroCopyError::InsufficientCapacity => 15016,
            ZeroCopyError::PlatformSizeOverflow => 15017,
        }
    }
}

#[cfg(feature = "pinocchio")]
impl From<ZeroCopyError> for pinocchio::program_error::ProgramError {
    fn from(e: ZeroCopyError) -> Self {
        pinocchio::program_error::ProgramError::Custom(e.into())
    }
}

#[cfg(feature = "solana")]
impl From<ZeroCopyError> for solana_program_error::ProgramError {
    fn from(e: ZeroCopyError) -> Self {
        solana_program_error::ProgramError::Custom(e.into())
    }
}

impl<Src, Dst: ?Sized>
    From<
        zerocopy::ConvertError<
            zerocopy::AlignmentError<Src, Dst>,
            zerocopy::SizeError<Src, Dst>,
            core::convert::Infallible,
        >,
    > for ZeroCopyError
{
    fn from(
        err: zerocopy::ConvertError<
            zerocopy::AlignmentError<Src, Dst>,
            zerocopy::SizeError<Src, Dst>,
            core::convert::Infallible,
        >,
    ) -> Self {
        match err {
            zerocopy::ConvertError::Alignment(_) => ZeroCopyError::UnalignedPointer,
            zerocopy::ConvertError::Size(_) => ZeroCopyError::Size,
            zerocopy::ConvertError::Validity(i) => ZeroCopyError::InvalidData(i),
        }
    }
}