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
use std::{
	borrow::Cow,
	ffi,
	io,
	os::raw::c_char,
	ptr::null,
};

pub unsafe fn from_cstr(s: *const c_char) -> io::Result<&'static str> {
	ffi::CStr::from_ptr(s)
		.to_str()
		.map_err(|e| io::Error::new(io::ErrorKind::Other, e))
}

#[derive(Clone, Debug)]
pub struct CStr<'a>(Cow<'a, ffi::CStr>);

impl<'a> CStr<'a> {
	pub fn from<T>(s: &'a T) -> Result<Self, ffi::NulError>
	where
		Self: CStrFrom<'a, T>,
	{
		CStrFrom::cstr_from(s)
	}

	pub fn as_ptr(&self) -> *const c_char {
		self.0.as_ptr()
	}
}

#[derive(Clone, Debug)]
pub struct NullableCStr<'a>(Option<Cow<'a, ffi::CStr>>);

impl<'a> NullableCStr<'a> {
	pub fn from<T>(s: &'a T) -> Result<Self, ffi::NulError>
	where
		Self: CStrFrom<'a, T>,
	{
		CStrFrom::cstr_from(s)
	}

	pub fn as_ptr(&self) -> *const c_char {
		match self.0 {
			Some(ref s) => s.as_ptr(),
			None => null(),
		}
	}
}

pub trait CStrFrom<'a, T>: Sized {
	fn cstr_from(_: &'a T) -> Result<Self, ffi::NulError>;
}

impl<'a, T: AsRef<str>> CStrFrom<'a, T> for CStr<'a> {
	fn cstr_from(s: &'a T) -> Result<Self, ffi::NulError> {
		Ok(Self(Cow::Owned(ffi::CString::new(s.as_ref())?)))
	}
}

impl<'a, T: AsRef<str>> CStrFrom<'a, Option<T>> for NullableCStr<'a> {
	fn cstr_from(s: &'a Option<T>) -> Result<Self, ffi::NulError> {
		match *s {
			Some(ref s) => Ok(Self(Some(Cow::Owned(ffi::CString::new(s.as_ref())?)))),
			None => Ok(Self(None)),
		}
	}
}