Trait ToGlibContainerFromSlice

pub trait ToGlibContainerFromSlice<'a, P>: Sized {
    type Storage;

    // Required methods
    fn to_glib_none_from_slice(t: &'a [Self]) -> (P, Self::Storage);
    fn to_glib_container_from_slice(t: &'a [Self]) -> (P, Self::Storage);
    fn to_glib_full_from_slice(t: &[Self]) -> P;
}

Required Associated Types

type Storage

Required Methods

fn to_glib_none_from_slice(t: &'a [Self]) -> (P, Self::Storage)

fn to_glib_container_from_slice(t: &'a [Self]) -> (P, Self::Storage)

fn to_glib_full_from_slice(t: &[Self]) -> P

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for &'a str

type Storage = (Vec<Stash<'a, *const i8, &'a str>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a str], ) -> (*const *const i8, <&'a str as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*const *const i8, <&'a str as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a str]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for &'a CStr

type Storage = (Vec<Stash<'a, *const i8, &'a CStr>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a CStr], ) -> (*const *const i8, <&'a CStr as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*const *const i8, <&'a CStr as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a CStr]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for &'a OsStr

type Storage = (Vec<Stash<'a, *const i8, &'a OsStr>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a OsStr], ) -> (*const *const i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*const *const i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a OsStr]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for &'a Path

type Storage = (Vec<Stash<'a, *const i8, &'a Path>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a Path], ) -> (*const *const i8, <&'a Path as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*const *const i8, <&'a Path as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a Path]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for CString

type Storage = (Vec<Stash<'a, *const i8, CString>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [CString], ) -> (*const *const i8, <CString as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*const *const i8, <CString as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[CString]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for String

type Storage = (Vec<Stash<'a, *const i8, String>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [String], ) -> (*const *const i8, <String as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*const *const i8, <String as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[String]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for OsString

type Storage = (Vec<Stash<'a, *const i8, OsString>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [OsString], ) -> (*const *const i8, <OsString as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*const *const i8, <OsString as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[OsString]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for PathBuf

type Storage = (Vec<Stash<'a, *const i8, PathBuf>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [PathBuf], ) -> (*const *const i8, <PathBuf as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*const *const i8, <PathBuf as ToGlibContainerFromSlice<'a, *const *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[PathBuf]) -> *const *const i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for &'a str

type Storage = (Vec<Stash<'a, *mut i8, &'a str>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a str], ) -> (*const *mut i8, <&'a str as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*const *mut i8, <&'a str as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a str]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for &'a CStr

type Storage = (Vec<Stash<'a, *mut i8, &'a CStr>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a CStr], ) -> (*const *mut i8, <&'a CStr as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*const *mut i8, <&'a CStr as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a CStr]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for &'a OsStr

type Storage = (Vec<Stash<'a, *mut i8, &'a OsStr>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a OsStr], ) -> (*const *mut i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*const *mut i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a OsStr]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for &'a Path

type Storage = (Vec<Stash<'a, *mut i8, &'a Path>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a Path], ) -> (*const *mut i8, <&'a Path as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*const *mut i8, <&'a Path as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a Path]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for CString

type Storage = (Vec<Stash<'a, *mut i8, CString>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [CString], ) -> (*const *mut i8, <CString as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*const *mut i8, <CString as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[CString]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for String

type Storage = (Vec<Stash<'a, *mut i8, String>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [String], ) -> (*const *mut i8, <String as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*const *mut i8, <String as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[String]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for OsString

type Storage = (Vec<Stash<'a, *mut i8, OsString>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [OsString], ) -> (*const *mut i8, <OsString as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*const *mut i8, <OsString as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[OsString]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for PathBuf

type Storage = (Vec<Stash<'a, *mut i8, PathBuf>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [PathBuf], ) -> (*const *mut i8, <PathBuf as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*const *mut i8, <PathBuf as ToGlibContainerFromSlice<'a, *const *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[PathBuf]) -> *const *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut f32> for f32

type Storage = PhantomData<&'a [f32]>

fn to_glib_none_from_slice( t: &'a [f32], ) -> (*mut f32, <f32 as ToGlibContainerFromSlice<'a, *mut f32>>::Storage)

fn to_glib_container_from_slice( t: &'a [f32], ) -> (*mut f32, <f32 as ToGlibContainerFromSlice<'a, *mut f32>>::Storage)

fn to_glib_full_from_slice(t: &[f32]) -> *mut f32

impl<'a> ToGlibContainerFromSlice<'a, *mut f64> for f64

type Storage = PhantomData<&'a [f64]>

fn to_glib_none_from_slice( t: &'a [f64], ) -> (*mut f64, <f64 as ToGlibContainerFromSlice<'a, *mut f64>>::Storage)

fn to_glib_container_from_slice( t: &'a [f64], ) -> (*mut f64, <f64 as ToGlibContainerFromSlice<'a, *mut f64>>::Storage)

fn to_glib_full_from_slice(t: &[f64]) -> *mut f64

impl<'a> ToGlibContainerFromSlice<'a, *mut i8> for i8

type Storage = PhantomData<&'a [i8]>

fn to_glib_none_from_slice( t: &'a [i8], ) -> (*mut i8, <i8 as ToGlibContainerFromSlice<'a, *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [i8], ) -> (*mut i8, <i8 as ToGlibContainerFromSlice<'a, *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[i8]) -> *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut i16> for i16

type Storage = PhantomData<&'a [i16]>

fn to_glib_none_from_slice( t: &'a [i16], ) -> (*mut i16, <i16 as ToGlibContainerFromSlice<'a, *mut i16>>::Storage)

fn to_glib_container_from_slice( t: &'a [i16], ) -> (*mut i16, <i16 as ToGlibContainerFromSlice<'a, *mut i16>>::Storage)

fn to_glib_full_from_slice(t: &[i16]) -> *mut i16

impl<'a> ToGlibContainerFromSlice<'a, *mut i32> for i32

type Storage = PhantomData<&'a [i32]>

fn to_glib_none_from_slice( t: &'a [i32], ) -> (*mut i32, <i32 as ToGlibContainerFromSlice<'a, *mut i32>>::Storage)

fn to_glib_container_from_slice( t: &'a [i32], ) -> (*mut i32, <i32 as ToGlibContainerFromSlice<'a, *mut i32>>::Storage)

fn to_glib_full_from_slice(t: &[i32]) -> *mut i32

impl<'a> ToGlibContainerFromSlice<'a, *mut i64> for i64

type Storage = PhantomData<&'a [i64]>

fn to_glib_none_from_slice( t: &'a [i64], ) -> (*mut i64, <i64 as ToGlibContainerFromSlice<'a, *mut i64>>::Storage)

fn to_glib_container_from_slice( t: &'a [i64], ) -> (*mut i64, <i64 as ToGlibContainerFromSlice<'a, *mut i64>>::Storage)

fn to_glib_full_from_slice(t: &[i64]) -> *mut i64

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for &'a str

type Storage = (Vec<Stash<'a, *const i8, &'a str>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a str], ) -> (*mut *const i8, <&'a str as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*mut *const i8, <&'a str as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a str]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for &'a CStr

type Storage = (Vec<Stash<'a, *const i8, &'a CStr>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a CStr], ) -> (*mut *const i8, <&'a CStr as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*mut *const i8, <&'a CStr as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a CStr]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for &'a OsStr

type Storage = (Vec<Stash<'a, *const i8, &'a OsStr>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a OsStr], ) -> (*mut *const i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*mut *const i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a OsStr]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for &'a Path

type Storage = (Vec<Stash<'a, *const i8, &'a Path>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [&'a Path], ) -> (*mut *const i8, <&'a Path as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*mut *const i8, <&'a Path as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a Path]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for CString

type Storage = (Vec<Stash<'a, *const i8, CString>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [CString], ) -> (*mut *const i8, <CString as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*mut *const i8, <CString as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[CString]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for String

type Storage = (Vec<Stash<'a, *const i8, String>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [String], ) -> (*mut *const i8, <String as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*mut *const i8, <String as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[String]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for OsString

type Storage = (Vec<Stash<'a, *const i8, OsString>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [OsString], ) -> (*mut *const i8, <OsString as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*mut *const i8, <OsString as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[OsString]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for PathBuf

type Storage = (Vec<Stash<'a, *const i8, PathBuf>>, Option<Vec<*const i8>>)

fn to_glib_none_from_slice( t: &'a [PathBuf], ) -> (*mut *const i8, <PathBuf as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*mut *const i8, <PathBuf as ToGlibContainerFromSlice<'a, *mut *const i8>>::Storage)

fn to_glib_full_from_slice(t: &[PathBuf]) -> *mut *const i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for &'a str

type Storage = (Vec<Stash<'a, *mut i8, &'a str>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a str], ) -> (*mut *mut i8, <&'a str as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*mut *mut i8, <&'a str as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a str]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for &'a CStr

type Storage = (Vec<Stash<'a, *mut i8, &'a CStr>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a CStr], ) -> (*mut *mut i8, <&'a CStr as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*mut *mut i8, <&'a CStr as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a CStr]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for &'a OsStr

type Storage = (Vec<Stash<'a, *mut i8, &'a OsStr>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a OsStr], ) -> (*mut *mut i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*mut *mut i8, <&'a OsStr as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a OsStr]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for &'a Path

type Storage = (Vec<Stash<'a, *mut i8, &'a Path>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [&'a Path], ) -> (*mut *mut i8, <&'a Path as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*mut *mut i8, <&'a Path as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[&'a Path]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for CString

type Storage = (Vec<Stash<'a, *mut i8, CString>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [CString], ) -> (*mut *mut i8, <CString as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*mut *mut i8, <CString as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[CString]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for String

type Storage = (Vec<Stash<'a, *mut i8, String>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [String], ) -> (*mut *mut i8, <String as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*mut *mut i8, <String as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[String]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for OsString

type Storage = (Vec<Stash<'a, *mut i8, OsString>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [OsString], ) -> (*mut *mut i8, <OsString as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*mut *mut i8, <OsString as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[OsString]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for PathBuf

type Storage = (Vec<Stash<'a, *mut i8, PathBuf>>, Option<Vec<*mut i8>>)

fn to_glib_none_from_slice( t: &'a [PathBuf], ) -> (*mut *mut i8, <PathBuf as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*mut *mut i8, <PathBuf as ToGlibContainerFromSlice<'a, *mut *mut i8>>::Storage)

fn to_glib_full_from_slice(t: &[PathBuf]) -> *mut *mut i8

impl<'a> ToGlibContainerFromSlice<'a, *mut u8> for u8

type Storage = PhantomData<&'a [u8]>

fn to_glib_none_from_slice( t: &'a [u8], ) -> (*mut u8, <u8 as ToGlibContainerFromSlice<'a, *mut u8>>::Storage)

fn to_glib_container_from_slice( t: &'a [u8], ) -> (*mut u8, <u8 as ToGlibContainerFromSlice<'a, *mut u8>>::Storage)

fn to_glib_full_from_slice(t: &[u8]) -> *mut u8

impl<'a> ToGlibContainerFromSlice<'a, *mut u16> for u16

type Storage = PhantomData<&'a [u16]>

fn to_glib_none_from_slice( t: &'a [u16], ) -> (*mut u16, <u16 as ToGlibContainerFromSlice<'a, *mut u16>>::Storage)

fn to_glib_container_from_slice( t: &'a [u16], ) -> (*mut u16, <u16 as ToGlibContainerFromSlice<'a, *mut u16>>::Storage)

fn to_glib_full_from_slice(t: &[u16]) -> *mut u16

impl<'a> ToGlibContainerFromSlice<'a, *mut u32> for u32

type Storage = PhantomData<&'a [u32]>

fn to_glib_none_from_slice( t: &'a [u32], ) -> (*mut u32, <u32 as ToGlibContainerFromSlice<'a, *mut u32>>::Storage)

fn to_glib_container_from_slice( t: &'a [u32], ) -> (*mut u32, <u32 as ToGlibContainerFromSlice<'a, *mut u32>>::Storage)

fn to_glib_full_from_slice(t: &[u32]) -> *mut u32

impl<'a> ToGlibContainerFromSlice<'a, *mut u64> for u64

type Storage = PhantomData<&'a [u64]>

fn to_glib_none_from_slice( t: &'a [u64], ) -> (*mut u64, <u64 as ToGlibContainerFromSlice<'a, *mut u64>>::Storage)

fn to_glib_container_from_slice( t: &'a [u64], ) -> (*mut u64, <u64 as ToGlibContainerFromSlice<'a, *mut u64>>::Storage)

fn to_glib_full_from_slice(t: &[u64]) -> *mut u64

impl<'a, T> ToGlibContainerFromSlice<'a, *const GSList> for &'a T

where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

type Storage = (Option<SList>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, &'a T>>)

fn to_glib_none_from_slice( t: &'a [&'a T], ) -> (*const GSList, <&'a T as ToGlibContainerFromSlice<'a, *const GSList>>::Storage)

fn to_glib_container_from_slice( _t: &'a [&'a T], ) -> (*const GSList, <&'a T as ToGlibContainerFromSlice<'a, *const GSList>>::Storage)

fn to_glib_full_from_slice(_t: &[&'a T]) -> *const GSList

impl<'a, T> ToGlibContainerFromSlice<'a, *mut GSList> for &'a T

where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

type Storage = (Option<SList>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, &'a T>>)

fn to_glib_none_from_slice( t: &'a [&'a T], ) -> (*mut GSList, <&'a T as ToGlibContainerFromSlice<'a, *mut GSList>>::Storage)

fn to_glib_container_from_slice( t: &'a [&'a T], ) -> (*mut GSList, <&'a T as ToGlibContainerFromSlice<'a, *mut GSList>>::Storage)

fn to_glib_full_from_slice(t: &[&'a T]) -> *mut GSList

Implementors

impl<'a> ToGlibContainerFromSlice<'a, *const *const i8> for GString

type Storage = (Vec<Stash<'a, *const i8, GString>>, Option<Vec<*const i8>>)

impl<'a> ToGlibContainerFromSlice<'a, *const *mut i8> for GString

type Storage = (Vec<Stash<'a, *mut i8, GString>>, Option<Vec<*mut i8>>)

impl<'a> ToGlibContainerFromSlice<'a, *mut *const i8> for GString

type Storage = (Vec<Stash<'a, *const i8, GString>>, Option<Vec<*const i8>>)

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut i8> for GString

type Storage = (Vec<Stash<'a, *mut i8, GString>>, Option<Vec<*mut i8>>)

impl<'a> ToGlibContainerFromSlice<'a, *mut usize> for Type

type Storage = PhantomData<&'a [Type]>

impl<'a, T> ToGlibContainerFromSlice<'a, *const GList> for T

where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

type Storage = (Option<List>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)

impl<'a, T> ToGlibContainerFromSlice<'a, *const GPtrArray> for T

where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

type Storage = (Option<PtrArray>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)

impl<'a, T> ToGlibContainerFromSlice<'a, *mut GList> for T

where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

type Storage = (Option<List>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)

impl<'a, T> ToGlibContainerFromSlice<'a, *mut GPtrArray> for T

where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

type Storage = (Option<PtrArray>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)