tipc-std 0.1.0

TIPC standard library type provider
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

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 KylinSoft Co., Ltd. <https://www.kylinos.cn/>
// See LICENSES for license details.

//! FFI types for tipc-std.

pub use alloc_crate::ffi::CString;
use alloc_crate::vec::Vec;

use crate::alloc_crate;

/// Error returned when creating a `CString` fails.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TryNewError {
    /// An interior nul byte was found at the given position.
    NulError(usize, Vec<u8>),
    /// Memory allocation failed.
    AllocError,
}

/// A CString-like type that uses fallible allocation.
pub struct FallibleCString(CString);

impl FallibleCString {
    /// Creates a new `FallibleCString` from a byte slice without nul check.
    ///
    /// # Safety
    ///
    /// The caller must ensure `v` contains no nul bytes and has a nul
    /// terminator.
    pub unsafe fn from_vec_unchecked(v: Vec<u8>) -> Result<Self, TryNewError> {
        // SAFETY: caller guarantees no interior nul + nul terminated.
        let cs = unsafe { CString::from_vec_unchecked(v) };
        Ok(FallibleCString(cs))
    }

    /// Creates a new `FallibleCString` from a byte slice.
    pub fn new(v: Vec<u8>) -> Result<Self, TryNewError> {
        match CString::new(v) {
            Ok(cs) => Ok(FallibleCString(cs)),
            Err(e) => Err(TryNewError::NulError(e.nul_position(), e.into_vec())),
        }
    }
}

impl core::ops::Deref for FallibleCString {
    type Target = CString;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<crate::alloc::AllocError> for TryNewError {
    fn from(_err: crate::alloc::AllocError) -> Self {
        TryNewError::AllocError
    }
}