Trait titanium::desktop::gui::libdruid::piet::cairo::glib::translate::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

Implementations on Foreign Types

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

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

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, *mut *const i8> for &'a OsStr

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

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, *const *const i8> for OsString

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

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, *mut *const i8> for String

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

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 &'a str

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

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 i64> for i64

type Storage = &'a [i64]

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

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

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

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

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

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, *const *mut i8> for String

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

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 &'a str

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

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, *mut i32> for i32

type Storage = &'a [i32]

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

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

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

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

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

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, *mut *mut i8> for PathBuf

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

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 i16> for i16

type Storage = &'a [i16]

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

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

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

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

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

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 *const i8> for PathBuf

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

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, *mut i8> for i8

type Storage = &'a [i8]

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

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

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

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

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

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>, Global>, Option<Vec<*const i8, Global>>)

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, T> ToGlibContainerFromSlice<'a, *mut GSList> for &'a Twhere T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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

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

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

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

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, *const *mut i8> for PathBuf

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

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 *mut i8> for OsString

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

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, *const *mut i8> for &'a Path

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

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 &'a OsStr

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

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, *mut f64> for f64

type Storage = &'a [f64]

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

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

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

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

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

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 u64> for u64

type Storage = &'a [u64]

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

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

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

impl<'a, T> ToGlibContainerFromSlice<'a, *const GSList> for &'a Twhere T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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

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> ToGlibContainerFromSlice<'a, *mut *mut i8> for &'a Path

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

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 f32> for f32

type Storage = &'a [f32]

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

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

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

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

type Storage = &'a [u8]

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

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

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

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

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

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 String

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

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, *mut u32> for u32

type Storage = &'a [u32]

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

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

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

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

type Storage = &'a [u16]

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

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

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

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

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

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, *const *mut _GdkAtom> for Atom

type Storage = (Vec<Stash<'a, *mut _GdkAtom, Atom>, Global>, Option<Vec<*mut _GdkAtom, Global>>)

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

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

fn to_glib_full_from_slice(_: &[Atom]) -> *const *mut _GdkAtom

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut _GdkAtom> for Atom

type Storage = (Vec<Stash<'a, *mut _GdkAtom, Atom>, Global>, Option<Vec<*mut _GdkAtom, Global>>)

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

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

fn to_glib_full_from_slice(_: &[Atom]) -> *mut *mut _GdkAtom

Implementors

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

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

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

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

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

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

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

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

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

type Storage = Option<Vec<usize, Global>>

impl<'a, T> ToGlibContainerFromSlice<'a, *const GList> for Twhere T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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

impl<'a, T> ToGlibContainerFromSlice<'a, *const GPtrArray> for Twhere T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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

impl<'a, T> ToGlibContainerFromSlice<'a, *mut GList> for Twhere T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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

impl<'a, T> ToGlibContainerFromSlice<'a, *mut GPtrArray> for Twhere T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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