Trait ToGlibContainerFromSlice 

pub trait ToGlibContainerFromSlice<'a, P>
where
    Self: 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".

Implementations on Foreign Types

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, Self::Storage)

fn to_glib_container_from_slice( _t: &'a [&'a T], ) -> (*const GSList, Self::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, Self::Storage)

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

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*const *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*const *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*mut *const c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a CStr], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a OsStr], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a Path], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [&'a str], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [CString], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [OsString], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [PathBuf], ) -> (*mut *mut c_char, Self::Storage)

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

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 c_char, Self::Storage)

fn to_glib_container_from_slice( t: &'a [String], ) -> (*mut *mut c_char, Self::Storage)

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

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

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

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

fn to_glib_container_from_slice(t: &'a [f32]) -> (*mut f32, Self::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, Self::Storage)

fn to_glib_container_from_slice(t: &'a [f64]) -> (*mut f64, Self::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, Self::Storage)

fn to_glib_container_from_slice(t: &'a [i8]) -> (*mut i8, Self::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, Self::Storage)

fn to_glib_container_from_slice(t: &'a [i16]) -> (*mut i16, Self::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, Self::Storage)

fn to_glib_container_from_slice(t: &'a [i32]) -> (*mut i32, Self::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, Self::Storage)

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

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

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

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

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

fn to_glib_container_from_slice(t: &'a [u8]) -> (*mut u8, Self::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, Self::Storage)

fn to_glib_container_from_slice(t: &'a [u16]) -> (*mut u16, Self::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, Self::Storage)

fn to_glib_container_from_slice(t: &'a [u32]) -> (*mut u32, Self::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, Self::Storage)

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

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

Implementors

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>>)

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]>