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;
}

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, *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 i8, &'a str>, Global>, Option<Vec<mut i8, Global>>)

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 i8, &'a str>, Global>, Option<Vec<mut i8, Global>>)

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 i8, &'a str>, Global>, Option<Vec<const i8, Global>>)

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 i8, &'a str>, Global>, Option<Vec<const i8, Global>>)

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 i8, String>, Global>, Option<Vec<mut i8, Global>>)

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 i8, String>, Global>, Option<Vec<mut i8, Global>>)

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

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

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 i8, &'a Path>, Global>, Option<Vec<mut i8, Global>>)

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 i8, &'a Path>, Global>, Option<Vec<mut i8, Global>>)

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 i8, &'a Path>, Global>, Option<Vec<const i8, Global>>)

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 i8, &'a Path>, Global>, Option<Vec<const i8, Global>>)

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 i8, PathBuf>, Global>, Option<Vec<mut i8, Global>>)

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 i8, PathBuf>, Global>, Option<Vec<mut i8, Global>>)

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

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

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 i8, &'a OsStr>, Global>, Option<Vec<mut i8, Global>>)

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 i8, &'a OsStr>, Global>, Option<Vec<mut i8, Global>>)

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 i8, &'a OsStr>, Global>, Option<Vec<const i8, Global>>)

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 i8, &'a OsStr>, Global>, Option<Vec<const i8, Global>>)

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 i8, OsString>, Global>, Option<Vec<mut i8, Global>>)

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 i8, OsString>, Global>, Option<Vec<mut i8, Global>>)

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

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

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

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

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 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 T where
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 T where
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 T where
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 T where
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,

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