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", 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 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 &'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 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 *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 *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 &'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 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, *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, *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 *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 &'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 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 *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 *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 &'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 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 *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 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

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

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