Trait glib::translate::ToGlibContainerFromSlice

source · [−]

pub trait ToGlibContainerFromSlice<'a, P> where
    Self: Sized, {
    type Storage;
    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;
}

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, *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, *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 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 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, *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 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, *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> 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 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 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 str

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

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

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

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

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

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, const const i8> for &'a str

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

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

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

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

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

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 String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors

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

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

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

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

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

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

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

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

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

type Storage = Option<Vec<GType>>

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