Struct glib::char::Char

pub struct Char(pub c_char);

Wrapper for values where C functions expect a plain C char

Consider the following C function prototype from glib:

void g_key_file_set_list_separator (GKeyFile *key_file, gchar separator);

This function plainly expects a byte as the separator argument. However, having this function exposed to Rust as the following would be inconvenient:

impl KeyFile {
    pub fn set_list_separator(&self, separator: libc:c_char) { }
}

This would be inconvenient because users would have to do the conversion from a Rust char to an libc::c_char by hand, which is just a type alias for i8 on most system.

This Char type is a wrapper over an libc::c_char, so that we can pass it to Glib or C functions. The check for whether a Rust char (a Unicode scalar value) actually fits in a libc::c_char is done in the new function; see its documentation for details.

The inner libc::c_char (which is equivalent to i8) can be extracted with .0, or by calling my_char.into_glib().

Examples

use glib::Char;
use std::convert::TryFrom;

Char::from(b'a');
Char::try_from('a').unwrap();
assert!(Char::try_from('☔').is_err());

extern "C" fn have_a_byte(b: libc::c_char);

have_a_byte(Char::from(b'a').into_glib());

Tuple Fields

0: c_char

Trait Implementations

impl Clone for Char

fn clone(&self) -> Char

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Char

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Char> for char

fn from(c: Char) -> char

Converts to this type from the input type.

impl From<Char> for u8

fn from(c: Char) -> u8

Converts to this type from the input type.

impl From<u8> for Char

fn from(c: u8) -> Char

Converts to this type from the input type.

impl PartialEq for Char

fn eq(&self, other: &Char) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<char> for Char

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(c: char) -> Result<Char, Self::Error>

Performs the conversion.

impl Copy for Char

impl Eq for Char

impl StructuralPartialEq for Char