glib/
value.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3// rustdoc-stripper-ignore-next
4//! `Value` binding and helper traits.
5//!
6//! The type of a [`Value`](struct.Value.html) is dynamic in that it generally
7//! isn't known at compile time but once created a `Value` can't change its
8//! type.
9//!
10//! [`SendValue`](struct.SendValue.html) is a version of [`Value`](struct.Value.html)
11//! that can only store types that implement `Send` and as such implements `Send` itself. It
12//! dereferences to `Value` so it can be used everywhere `Value` references are accepted.
13//!
14//! Supported types are `bool`, `i8`, `u8`, `i32`, `u32`, `i64`, `u64`, `f32`,
15//! `f64`, `String` and objects (`T: IsA<Object>`).
16//!
17//! # Examples
18//!
19//! ```
20//! use glib::prelude::*; // or `use gtk::prelude::*;`
21//! use glib::Value;
22//!
23//! // Value implement From<&i32>, From<&str> and From<Option<&str>>.
24//! // Another option is the `ToValue` trait.
25//! let mut num = 10.to_value();
26//! let mut hello = Value::from("Hello!");
27//! let none: Option<&str> = None;
28//! let str_none = none.to_value();
29//!
30//! // `is` tests the type of the value.
31//! assert!(num.is::<i32>());
32//! assert!(hello.is::<String>());
33//!
34//! // `get` tries to get an optional value of the specified type
35//! // and returns an `Err` if the type doesn't match.
36//! assert_eq!(num.get(), Ok(10));
37//! assert!(num.get::<String>().is_err());
38//! assert_eq!(hello.get(), Ok(String::from("Hello!")));
39//! assert_eq!(hello.get::<String>(), Ok(String::from("Hello!")));
40//! assert_eq!(str_none.get::<Option<String>>(), Ok(None));
41//! ```
42
43use std::{
44    convert::Infallible,
45    error,
46    ffi::CStr,
47    fmt, mem,
48    num::{NonZeroI32, NonZeroI64, NonZeroI8, NonZeroU32, NonZeroU64, NonZeroU8},
49    ops::Deref,
50    path::{Path, PathBuf},
51    ptr,
52};
53
54use libc::{c_char, c_void};
55
56use crate::{
57    ffi, gobject_ffi,
58    gstring::GString,
59    prelude::*,
60    translate::*,
61    types::{Pointee, Pointer, Type},
62    GStr,
63};
64
65// rustdoc-stripper-ignore-next
66/// A type that can be stored in `Value`s.
67pub trait ValueType: ToValue + for<'a> FromValue<'a> + 'static {
68    // rustdoc-stripper-ignore-next
69    /// Type to get the `Type` from.
70    ///
71    /// This exists only for handling optional types.
72    // FIXME: Should default to Self once associated type defaults are stabilized
73    // https://github.com/rust-lang/rust/issues/29661
74    type Type: StaticType;
75}
76
77// rustdoc-stripper-ignore-next
78/// A type that can be stored in `Value`s and is optional.
79///
80/// These are types were storing an `Option` is valid. Examples are `String` and all object types.
81pub trait ValueTypeOptional:
82    ValueType + ToValueOptional + FromValueOptional<'static> + StaticType
83{
84}
85
86impl<T, C, E> ValueType for Option<T>
87where
88    T: for<'a> FromValue<'a, Checker = C> + ValueTypeOptional + StaticType + 'static,
89    C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError<E>>,
90    E: error::Error + Send + Sized + 'static,
91{
92    type Type = T::Type;
93}
94
95// rustdoc-stripper-ignore-next
96/// Trait for `Value` type checkers.
97pub unsafe trait ValueTypeChecker {
98    type Error: error::Error + Send + Sized + 'static;
99
100    fn check(value: &Value) -> Result<(), Self::Error>;
101}
102
103// rustdoc-stripper-ignore-next
104/// An error returned from the [`get`](struct.Value.html#method.get) function
105/// on a [`Value`](struct.Value.html) for non-optional types an `Option`.
106#[derive(Clone, PartialEq, Eq, Debug)]
107pub struct ValueTypeMismatchError {
108    actual: Type,
109    requested: Type,
110}
111
112impl ValueTypeMismatchError {
113    pub fn new(actual: Type, requested: Type) -> Self {
114        Self { actual, requested }
115    }
116}
117
118impl ValueTypeMismatchError {
119    pub fn actual_type(&self) -> Type {
120        self.actual
121    }
122
123    pub fn requested_type(&self) -> Type {
124        self.requested
125    }
126}
127
128impl fmt::Display for ValueTypeMismatchError {
129    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
130        write!(
131            f,
132            "Value type mismatch. Actual {:?}, requested {:?}",
133            self.actual_type(),
134            self.requested_type(),
135        )
136    }
137}
138
139impl error::Error for ValueTypeMismatchError {}
140
141impl From<Infallible> for ValueTypeMismatchError {
142    fn from(e: Infallible) -> Self {
143        match e {}
144    }
145}
146
147// rustdoc-stripper-ignore-next
148/// Generic `Value` type checker for types.
149pub struct GenericValueTypeChecker<T>(std::marker::PhantomData<T>);
150
151unsafe impl<T: StaticType> ValueTypeChecker for GenericValueTypeChecker<T> {
152    type Error = ValueTypeMismatchError;
153
154    #[doc(alias = "g_type_check_value_holds")]
155    #[inline]
156    fn check(value: &Value) -> Result<(), Self::Error> {
157        unsafe {
158            if gobject_ffi::g_type_check_value_holds(&value.inner, T::static_type().into_glib())
159                == ffi::GFALSE
160            {
161                Err(ValueTypeMismatchError::new(
162                    Type::from_glib(value.inner.g_type),
163                    T::static_type(),
164                ))
165            } else {
166                Ok(())
167            }
168        }
169    }
170}
171
172pub struct CharTypeChecker();
173unsafe impl ValueTypeChecker for CharTypeChecker {
174    type Error = InvalidCharError;
175
176    #[inline]
177    fn check(value: &Value) -> Result<(), Self::Error> {
178        let v = value.get::<u32>()?;
179        match char::from_u32(v) {
180            Some(_) => Ok(()),
181            None => Err(InvalidCharError::CharConversionError),
182        }
183    }
184}
185
186// rustdoc-stripper-ignore-next
187/// An error returned from the [`get`](struct.Value.html#method.get) function
188/// on a [`Value`](struct.Value.html) for char (which are internally u32) types.
189#[derive(Clone, PartialEq, Eq, Debug)]
190pub enum InvalidCharError {
191    WrongValueType(ValueTypeMismatchError),
192    CharConversionError,
193}
194impl fmt::Display for InvalidCharError {
195    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
196        match self {
197            Self::WrongValueType(err) => err.fmt(f),
198            Self::CharConversionError => {
199                write!(f, "couldn't convert to char, invalid u32 contents")
200            }
201        }
202    }
203}
204impl error::Error for InvalidCharError {}
205
206impl From<ValueTypeMismatchError> for InvalidCharError {
207    fn from(err: ValueTypeMismatchError) -> Self {
208        Self::WrongValueType(err)
209    }
210}
211
212impl From<Infallible> for InvalidCharError {
213    fn from(e: Infallible) -> Self {
214        match e {}
215    }
216}
217
218// rustdoc-stripper-ignore-next
219/// An error returned from the [`get`](struct.Value.html#method.get)
220/// function on a [`Value`](struct.Value.html) for optional types.
221#[derive(Clone, PartialEq, Eq, Debug)]
222pub enum ValueTypeMismatchOrNoneError<E: error::Error> {
223    WrongValueType(E),
224    UnexpectedNone,
225}
226
227impl<E: error::Error> fmt::Display for ValueTypeMismatchOrNoneError<E> {
228    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
229        match self {
230            Self::WrongValueType(err) => <E as fmt::Display>::fmt(err, f),
231            Self::UnexpectedNone => write!(f, "Unexpected None",),
232        }
233    }
234}
235
236impl<E: error::Error> error::Error for ValueTypeMismatchOrNoneError<E> {}
237
238impl<E: error::Error> From<E> for ValueTypeMismatchOrNoneError<E> {
239    fn from(err: E) -> Self {
240        Self::WrongValueType(err)
241    }
242}
243
244// rustdoc-stripper-ignore-next
245/// Generic `Value` type checker for optional types.
246pub struct GenericValueTypeOrNoneChecker<T>(std::marker::PhantomData<T>);
247
248unsafe impl<T: StaticType> ValueTypeChecker for GenericValueTypeOrNoneChecker<T> {
249    type Error = ValueTypeMismatchOrNoneError<ValueTypeMismatchError>;
250
251    #[inline]
252    fn check(value: &Value) -> Result<(), Self::Error> {
253        GenericValueTypeChecker::<T>::check(value)?;
254
255        unsafe {
256            // Values are always zero-initialized so even if pointers are only 32 bits then the
257            // whole 64 bit value will be 0 for NULL pointers.
258            if value.inner.data[0].v_uint64 == 0 {
259                return Err(Self::Error::UnexpectedNone);
260            }
261        }
262
263        Ok(())
264    }
265}
266
267// rustdoc-stripper-ignore-next
268/// Trait to retrieve the contained value from a `Value`.
269///
270/// Usually this would not be used directly but from the [`get`](struct.Value.html#method.get)
271/// function on a [`Value`](struct.Value.html)
272pub unsafe trait FromValue<'a>: Sized {
273    // rustdoc-stripper-ignore-next
274    /// Value type checker.
275    type Checker: ValueTypeChecker;
276
277    // rustdoc-stripper-ignore-next
278    /// Get the contained value from a `Value`.
279    ///
280    /// # Safety
281    /// `Self::Checker::check()` must be called first and must not fail.
282    unsafe fn from_value(value: &'a Value) -> Self;
283}
284
285// rustdoc-stripper-ignore-next
286/// Trait for types that implement `FromValue` and are Optional.
287///
288/// This trait is auto-implemented for the appropriate types and is sealed.
289pub trait FromValueOptional<'a>: private::FromValueOptionalSealed<'a> {}
290
291impl<'a, T, C, E> FromValueOptional<'a> for T
292where
293    T: FromValue<'a, Checker = C>,
294    C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError<E>>,
295    E: error::Error + Send + Sized + 'static,
296{
297}
298
299mod private {
300    pub trait FromValueOptionalSealed<'a> {}
301
302    impl<'a, T, C, E> FromValueOptionalSealed<'a> for T
303    where
304        T: super::FromValue<'a, Checker = C>,
305        C: super::ValueTypeChecker<Error = super::ValueTypeMismatchOrNoneError<E>>,
306        E: super::error::Error + Send + Sized + 'static,
307    {
308    }
309}
310
311// rustdoc-stripper-ignore-next
312/// Wrapped `Value` type checker for optional types.
313pub struct ValueTypeOrNoneChecker<T, C, E>(std::marker::PhantomData<(T, C, E)>);
314
315unsafe impl<'a, T, C, E> ValueTypeChecker for ValueTypeOrNoneChecker<T, C, E>
316where
317    T: FromValue<'a, Checker = C> + StaticType,
318    C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError<E>>,
319    E: error::Error + Send + Sized + 'static,
320{
321    type Error = E;
322
323    #[inline]
324    fn check(value: &Value) -> Result<(), Self::Error> {
325        match T::Checker::check(value) {
326            Err(ValueTypeMismatchOrNoneError::UnexpectedNone) => Ok(()),
327            Err(ValueTypeMismatchOrNoneError::WrongValueType(err)) => Err(err),
328            Ok(_) => Ok(()),
329        }
330    }
331}
332
333// rustdoc-stripper-ignore-next
334/// Blanket implementation for all optional types.
335unsafe impl<'a, T, C, E> FromValue<'a> for Option<T>
336where
337    T: FromValue<'a, Checker = C> + StaticType,
338    C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError<E>>,
339    E: error::Error + Send + Sized + 'static,
340{
341    type Checker = ValueTypeOrNoneChecker<T, C, E>;
342
343    #[inline]
344    unsafe fn from_value(value: &'a Value) -> Self {
345        match T::Checker::check(value) {
346            Err(ValueTypeMismatchOrNoneError::UnexpectedNone) => None,
347            Err(ValueTypeMismatchOrNoneError::WrongValueType(_err)) => {
348                // This should've been caught by the caller already.
349                unreachable!();
350            }
351            Ok(_) => Some(T::from_value(value)),
352        }
353    }
354}
355
356// rustdoc-stripper-ignore-next
357/// Trait to convert a value to a `Value`.
358///
359/// Similar to other common conversion traits, the following invariants are guaranteed:
360///
361/// - **Invertibility**: `x.to_value().get().unwrap() == x`. In words, [`FromValue`] is the inverse of `ToValue`.
362/// - **Idempotence**: `x.to_value() == x.to_value().to_value()`.
363///   In words, applying `ToValue` multiple times yields the same result as applying it once.
364///   Idempotence also applies the other way around: `value.get::<Value>()` is a no-op.
365///
366/// There is also the possibility to wrap values within values, see [`BoxedValue`]. All (un-)boxing needs to be done
367/// manually, and will be preserved under the conversion methods.
368///
369/// The conversion methods may cause values to be cloned, which may result in reference counter changes or heap allocations depending
370/// on the source and target type.
371pub trait ToValue {
372    // rustdoc-stripper-ignore-next
373    /// Convert a value to a `Value`.
374    fn to_value(&self) -> Value;
375
376    // rustdoc-stripper-ignore-next
377    /// Returns the type identifier of `self`.
378    ///
379    /// This is the type of the value to be returned by `to_value`.
380    fn value_type(&self) -> Type;
381}
382
383// rustdoc-stripper-ignore-next
384/// Blanket implementation for all references.
385impl<T: ToValue + StaticType> ToValue for &T {
386    #[inline]
387    fn to_value(&self) -> Value {
388        T::to_value(*self)
389    }
390
391    #[inline]
392    fn value_type(&self) -> Type {
393        T::static_type()
394    }
395}
396
397// rustdoc-stripper-ignore-next
398/// Trait to convert an `Option` to a `Value` for optional types.
399pub trait ToValueOptional {
400    // rustdoc-stripper-ignore-next
401    /// Convert an `Option` to a `Value`.
402    #[allow(clippy::wrong_self_convention)]
403    fn to_value_optional(s: Option<&Self>) -> Value;
404}
405
406// rustdoc-stripper-ignore-next
407/// Blanket implementation for all optional types.
408impl<T: ToValueOptional + StaticType> ToValue for Option<T> {
409    #[inline]
410    fn to_value(&self) -> Value {
411        T::to_value_optional(self.as_ref())
412    }
413
414    #[inline]
415    fn value_type(&self) -> Type {
416        T::static_type()
417    }
418}
419
420impl<T: Into<Value> + ToValueOptional> From<Option<T>> for Value {
421    #[inline]
422    fn from(t: Option<T>) -> Self {
423        match t {
424            None => T::to_value_optional(None),
425            Some(t) => t.into(),
426        }
427    }
428}
429
430impl<T: ToValueOptional + StaticType> StaticType for Option<T> {
431    #[inline]
432    fn static_type() -> Type {
433        T::static_type()
434    }
435}
436
437impl<T: ToValueOptional + StaticType + ?Sized> ToValueOptional for &T {
438    #[inline]
439    fn to_value_optional(s: Option<&Self>) -> Value {
440        <T as ToValueOptional>::to_value_optional(s.as_ref().map(|s| **s))
441    }
442}
443
444#[inline]
445unsafe fn copy_value(value: *const gobject_ffi::GValue) -> *mut gobject_ffi::GValue {
446    let copy = ffi::g_malloc0(mem::size_of::<gobject_ffi::GValue>()) as *mut gobject_ffi::GValue;
447    copy_into_value(copy, value);
448    copy
449}
450
451#[inline]
452unsafe fn free_value(value: *mut gobject_ffi::GValue) {
453    clear_value(value);
454    ffi::g_free(value as *mut _);
455}
456
457#[inline]
458unsafe fn init_value(value: *mut gobject_ffi::GValue) {
459    ptr::write(value, mem::zeroed());
460}
461
462#[inline]
463unsafe fn copy_into_value(dest: *mut gobject_ffi::GValue, src: *const gobject_ffi::GValue) {
464    gobject_ffi::g_value_init(dest, (*src).g_type);
465    gobject_ffi::g_value_copy(src, dest);
466}
467
468#[inline]
469unsafe fn clear_value(value: *mut gobject_ffi::GValue) {
470    // Before GLib 2.48, unsetting a zeroed GValue would give critical warnings
471    // https://bugzilla.gnome.org/show_bug.cgi?id=755766
472    if (*value).g_type != gobject_ffi::G_TYPE_INVALID {
473        gobject_ffi::g_value_unset(value);
474    }
475}
476
477// TODO: Should use impl !Send for Value {} once stable
478crate::wrapper! {
479    // rustdoc-stripper-ignore-next
480    /// A generic value capable of carrying various types.
481    ///
482    /// Once created the type of the value can't be changed.
483    ///
484    /// Some types (e.g. `String` and objects) support `None` values while others
485    /// (e.g. numeric types) don't.
486    ///
487    /// `Value` does not implement the `Send` trait, but [`SendValue`](struct.SendValue.html) can be
488    /// used instead.
489    ///
490    /// See the [module documentation](index.html) for more details.
491    // rustdoc-stripper-ignore-next-stop
492    /// An opaque structure used to hold different types of values.
493    ///
494    /// The data within the structure has protected scope: it is accessible only
495    /// to functions within a [`TypeValueTable`][crate::TypeValueTable] structure, or implementations of
496    /// the g_value_*() API. That is, code portions which implement new fundamental
497    /// types.
498    ///
499    /// [`Value`][crate::Value] users cannot make any assumptions about how data is stored
500    /// within the 2 element `data` union, and the `g_type` member should
501    /// only be accessed through the G_VALUE_TYPE() macro.
502    #[doc(alias = "GValue")]
503    pub struct Value(BoxedInline<gobject_ffi::GValue>);
504
505    match fn {
506        copy => |ptr| copy_value(ptr),
507        free => |ptr| free_value(ptr),
508        init => |ptr| init_value(ptr),
509        copy_into => |dest, src| copy_into_value(dest, src),
510        clear => |ptr| clear_value(ptr),
511    }
512}
513
514impl Value {
515    // rustdoc-stripper-ignore-next
516    /// Creates a new `Value` that is initialized with `type_`.
517    ///
518    /// # Panics
519    ///
520    /// If `type_` can't be stored in a `Value` this function panics.
521    pub fn from_type(type_: Type) -> Self {
522        unsafe {
523            assert_eq!(
524                gobject_ffi::g_type_check_is_value_type(type_.into_glib()),
525                ffi::GTRUE
526            );
527            Self::from_type_unchecked(type_)
528        }
529    }
530
531    // rustdoc-stripper-ignore-next
532    /// Creates a new `Value` that is initialized with `type_`.
533    ///
534    /// # SAFETY
535    ///
536    /// This must be called with a valid `type_` that can be stored in `Value`s.
537    #[inline]
538    pub unsafe fn from_type_unchecked(type_: Type) -> Self {
539        unsafe {
540            let mut value = Value::uninitialized();
541            gobject_ffi::g_value_init(value.to_glib_none_mut().0, type_.into_glib());
542            value
543        }
544    }
545
546    // rustdoc-stripper-ignore-next
547    /// Creates a new `Value` that is initialized for a given `ValueType`.
548    #[inline]
549    pub fn for_value_type<T: ValueType>() -> Self {
550        unsafe { Value::from_type_unchecked(T::Type::static_type()) }
551    }
552
553    // rustdoc-stripper-ignore-next
554    /// Creates a new `String`-typed `Value` from a `'static` string.
555    #[inline]
556    #[doc(alias = "g_value_set_static_string")]
557    pub fn from_static_str(s: &'static GStr) -> Self {
558        unsafe {
559            let mut v = Self::from_type_unchecked(Type::STRING);
560            gobject_ffi::g_value_set_static_string(v.to_glib_none_mut().0, s.as_ptr());
561            v
562        }
563    }
564
565    #[cfg(feature = "v2_66")]
566    #[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
567    // rustdoc-stripper-ignore-next
568    /// Creates a new `String`-typed `Value` from a `'static` string that is also assumed to be
569    /// interned.
570    #[inline]
571    #[doc(alias = "g_value_set_interned_string")]
572    pub fn from_interned_str(s: &'static GStr) -> Self {
573        unsafe {
574            let mut v = Self::from_type_unchecked(Type::STRING);
575            gobject_ffi::g_value_set_interned_string(v.to_glib_none_mut().0, s.as_ptr());
576            v
577        }
578    }
579
580    // rustdoc-stripper-ignore-next
581    /// Tries to get a value of type `T`.
582    ///
583    /// Returns `Ok` if the type is correct.
584    #[inline]
585    pub fn get<'a, T>(
586        &'a self,
587    ) -> Result<T, <<T as FromValue<'a>>::Checker as ValueTypeChecker>::Error>
588    where
589        T: FromValue<'a>,
590    {
591        unsafe {
592            T::Checker::check(self)?;
593            Ok(T::from_value(self))
594        }
595    }
596
597    // rustdoc-stripper-ignore-next
598    /// Tries to get a value of an owned type `T`.
599    #[inline]
600    pub fn get_owned<T>(&self) -> Result<T, <<T as FromValue>::Checker as ValueTypeChecker>::Error>
601    where
602        T: for<'b> FromValue<'b> + 'static,
603    {
604        unsafe {
605            T::Checker::check(self)?;
606            Ok(FromValue::from_value(self))
607        }
608    }
609
610    // rustdoc-stripper-ignore-next
611    /// Returns `true` if the type of the value corresponds to `T`
612    /// or is a sub-type of `T`.
613    #[inline]
614    pub fn is<T: StaticType>(&self) -> bool {
615        self.is_type(T::static_type())
616    }
617
618    // rustdoc-stripper-ignore-next
619    /// Returns `true` if the type of the value corresponds to `type_`
620    /// or is a sub-type of `type_`.
621    #[inline]
622    pub fn is_type(&self, type_: Type) -> bool {
623        self.type_().is_a(type_)
624    }
625
626    // rustdoc-stripper-ignore-next
627    /// Returns the type of the value.
628    #[inline]
629    pub fn type_(&self) -> Type {
630        unsafe { from_glib(self.inner.g_type) }
631    }
632
633    // rustdoc-stripper-ignore-next
634    /// Returns whether `Value`s of type `src` can be transformed to type `dst`.
635    // rustdoc-stripper-ignore-next-stop
636    /// Check whether [`transform()`][Self::transform()] is able to transform values
637    /// of type `src_type` into values of type `dest_type`. Note that for
638    /// the types to be transformable, they must be compatible or a
639    /// transformation function must be registered.
640    /// ## `src_type`
641    /// Source type.
642    /// ## `dest_type`
643    /// Target type.
644    ///
645    /// # Returns
646    ///
647    /// [`true`] if the transformation is possible, [`false`] otherwise.
648    #[doc(alias = "g_value_type_transformable")]
649    pub fn type_transformable(src: Type, dst: Type) -> bool {
650        unsafe {
651            from_glib(gobject_ffi::g_value_type_transformable(
652                src.into_glib(),
653                dst.into_glib(),
654            ))
655        }
656    }
657
658    // rustdoc-stripper-ignore-next
659    /// Tries to transform the value into a value of the target type
660    // rustdoc-stripper-ignore-next-stop
661    /// Tries to cast the contents of `self` into a type appropriate
662    /// to store in `dest_value`, e.g. to transform a `G_TYPE_INT` value
663    /// into a `G_TYPE_FLOAT` value. Performing transformations between
664    /// value types might incur precision lossage. Especially
665    /// transformations into strings might reveal seemingly arbitrary
666    /// results and shouldn't be relied upon for production code (such
667    /// as rcfile value or object property serialization).
668    /// ## `dest_value`
669    /// Target value.
670    ///
671    /// # Returns
672    ///
673    /// Whether a transformation rule was found and could be applied.
674    ///  Upon failing transformations, `dest_value` is left untouched.
675    #[doc(alias = "g_value_transform")]
676    pub fn transform<T: ValueType>(&self) -> Result<Value, crate::BoolError> {
677        self.transform_with_type(T::Type::static_type())
678    }
679
680    // rustdoc-stripper-ignore-next
681    /// Tries to transform the value into a value of the target type
682    #[doc(alias = "g_value_transform")]
683    pub fn transform_with_type(&self, type_: Type) -> Result<Value, crate::BoolError> {
684        unsafe {
685            let mut dest = Value::from_type(type_);
686            if from_glib(gobject_ffi::g_value_transform(
687                self.to_glib_none().0,
688                dest.to_glib_none_mut().0,
689            )) {
690                Ok(dest)
691            } else {
692                Err(crate::bool_error!(
693                    "Can't transform value of type '{}' into '{}'",
694                    self.type_(),
695                    type_
696                ))
697            }
698        }
699    }
700
701    // rustdoc-stripper-ignore-next
702    /// Consumes `Value` and returns the corresponding `GValue`.
703    #[inline]
704    pub fn into_raw(self) -> gobject_ffi::GValue {
705        unsafe {
706            let s = mem::ManuallyDrop::new(self);
707            ptr::read(&s.inner)
708        }
709    }
710
711    // rustdoc-stripper-ignore-next
712    /// Converts a `Value` into a `SendValue`. This fails if `self` does not store a value of type
713    /// `T`. It is required for `T` to be `Send` to call this function.
714    #[inline]
715    pub fn try_into_send_value<T: Send + StaticType>(self) -> Result<SendValue, Self> {
716        if self.type_().is_a(T::static_type()) {
717            unsafe { Ok(SendValue::unsafe_from(self.into_raw())) }
718        } else {
719            Err(self)
720        }
721    }
722
723    // rustdoc-stripper-ignore-next
724    /// Converts a `Value` into a `SendValue`.
725    ///
726    /// # Safety
727    ///
728    /// The type of the value contained in `self` must be `Send`.
729    #[inline]
730    pub unsafe fn into_send_value(self) -> SendValue {
731        SendValue::unsafe_from(self.into_raw())
732    }
733
734    fn content_debug_string(&self) -> GString {
735        unsafe { from_glib_full(gobject_ffi::g_strdup_value_contents(self.to_glib_none().0)) }
736    }
737}
738
739impl fmt::Debug for Value {
740    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
741        write!(f, "({}) {}", self.type_(), self.content_debug_string())
742    }
743}
744
745impl<'a, T: ?Sized + ToValue> From<&'a T> for Value {
746    #[inline]
747    fn from(value: &'a T) -> Self {
748        value.to_value()
749    }
750}
751
752impl From<SendValue> for Value {
753    #[inline]
754    fn from(value: SendValue) -> Self {
755        unsafe { Value::unsafe_from(value.into_raw()) }
756    }
757}
758
759impl ToValue for Value {
760    #[inline]
761    fn to_value(&self) -> Value {
762        self.clone()
763    }
764
765    #[inline]
766    fn value_type(&self) -> Type {
767        self.type_()
768    }
769}
770
771impl ToValue for &Value {
772    #[inline]
773    fn to_value(&self) -> Value {
774        (*self).clone()
775    }
776
777    #[inline]
778    fn value_type(&self) -> Type {
779        self.type_()
780    }
781}
782
783pub struct NopChecker;
784
785unsafe impl ValueTypeChecker for NopChecker {
786    type Error = Infallible;
787
788    #[inline]
789    fn check(_value: &Value) -> Result<(), Self::Error> {
790        Ok(())
791    }
792}
793
794unsafe impl<'a> FromValue<'a> for Value {
795    type Checker = NopChecker;
796
797    #[inline]
798    unsafe fn from_value(value: &'a Value) -> Self {
799        value.clone()
800    }
801}
802
803unsafe impl<'a> FromValue<'a> for &'a Value {
804    type Checker = NopChecker;
805
806    #[inline]
807    unsafe fn from_value(value: &'a Value) -> Self {
808        value
809    }
810}
811
812impl ToValue for SendValue {
813    #[inline]
814    fn to_value(&self) -> Value {
815        unsafe { from_glib_none(self.to_glib_none().0) }
816    }
817
818    #[inline]
819    fn value_type(&self) -> Type {
820        self.type_()
821    }
822}
823
824impl ToValue for &SendValue {
825    #[inline]
826    fn to_value(&self) -> Value {
827        unsafe { from_glib_none(self.to_glib_none().0) }
828    }
829
830    #[inline]
831    fn value_type(&self) -> Type {
832        self.type_()
833    }
834}
835
836impl StaticType for BoxedValue {
837    #[inline]
838    fn static_type() -> Type {
839        unsafe { from_glib(gobject_ffi::g_value_get_type()) }
840    }
841}
842
843crate::wrapper! {
844    // rustdoc-stripper-ignore-next
845    /// A version of [`Value`](struct.Value.html) for storing `Send` types, that implements Send
846    /// itself.
847    ///
848    /// See the [module documentation](index.html) for more details.
849    #[doc(alias = "GValue")]
850    pub struct SendValue(BoxedInline<gobject_ffi::GValue>);
851
852    match fn {
853        copy => |ptr| copy_value(ptr),
854        free => |ptr| free_value(ptr),
855        init => |ptr| init_value(ptr),
856        copy_into => |dest, src| copy_into_value(dest, src),
857        clear => |ptr| clear_value(ptr),
858    }
859}
860
861unsafe impl Send for SendValue {}
862
863impl SendValue {
864    // rustdoc-stripper-ignore-next
865    /// Consumes `SendValue` and returns the corresponding `GValue`.
866    #[inline]
867    pub fn into_raw(self) -> gobject_ffi::GValue {
868        unsafe {
869            let s = mem::ManuallyDrop::new(self);
870            ptr::read(&s.inner)
871        }
872    }
873    #[inline]
874    pub fn from_owned<T: Send + Into<Value>>(t: T) -> Self {
875        unsafe { Self::unsafe_from(t.into().into_raw()) }
876    }
877}
878
879impl fmt::Debug for SendValue {
880    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
881        write!(f, "({}) {}", self.type_(), self.content_debug_string())
882    }
883}
884
885impl Deref for SendValue {
886    type Target = Value;
887
888    #[inline]
889    fn deref(&self) -> &Value {
890        unsafe { &*(self as *const SendValue as *const Value) }
891    }
892}
893
894impl<'a, T: ?Sized + ToSendValue> From<&'a T> for SendValue {
895    #[inline]
896    fn from(value: &'a T) -> Self {
897        value.to_send_value()
898    }
899}
900
901// rustdoc-stripper-ignore-next
902/// Converts to `SendValue`.
903pub trait ToSendValue: Send + ToValue {
904    // rustdoc-stripper-ignore-next
905    /// Returns a `SendValue` clone of `self`.
906    fn to_send_value(&self) -> SendValue;
907}
908
909impl<T: Send + ToValue + ?Sized> ToSendValue for T {
910    #[inline]
911    fn to_send_value(&self) -> SendValue {
912        unsafe { SendValue::unsafe_from(self.to_value().into_raw()) }
913    }
914}
915
916unsafe impl<'a> FromValue<'a> for &'a str {
917    type Checker = GenericValueTypeOrNoneChecker<Self>;
918
919    #[inline]
920    unsafe fn from_value(value: &'a Value) -> Self {
921        let ptr = gobject_ffi::g_value_get_string(value.to_glib_none().0);
922        CStr::from_ptr(ptr).to_str().expect("Invalid UTF-8")
923    }
924}
925
926impl ToValue for str {
927    fn to_value(&self) -> Value {
928        unsafe {
929            let mut value = Value::for_value_type::<String>();
930
931            gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, self.to_glib_full());
932
933            value
934        }
935    }
936
937    fn value_type(&self) -> Type {
938        String::static_type()
939    }
940}
941
942impl ToValue for &str {
943    fn to_value(&self) -> Value {
944        (*self).to_value()
945    }
946
947    fn value_type(&self) -> Type {
948        String::static_type()
949    }
950}
951
952impl ToValueOptional for str {
953    fn to_value_optional(s: Option<&Self>) -> Value {
954        let mut value = Value::for_value_type::<String>();
955        unsafe {
956            gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, s.to_glib_full());
957        }
958
959        value
960    }
961}
962
963impl ValueType for String {
964    type Type = String;
965}
966
967impl ValueTypeOptional for String {}
968
969unsafe impl<'a> FromValue<'a> for String {
970    type Checker = GenericValueTypeOrNoneChecker<Self>;
971
972    unsafe fn from_value(value: &'a Value) -> Self {
973        String::from(<&str>::from_value(value))
974    }
975}
976
977impl ToValue for String {
978    fn to_value(&self) -> Value {
979        <&str>::to_value(&self.as_str())
980    }
981
982    fn value_type(&self) -> Type {
983        String::static_type()
984    }
985}
986
987impl From<String> for Value {
988    #[inline]
989    fn from(s: String) -> Self {
990        s.to_value()
991    }
992}
993
994impl ToValueOptional for String {
995    fn to_value_optional(s: Option<&Self>) -> Value {
996        <str>::to_value_optional(s.as_ref().map(|s| s.as_str()))
997    }
998}
999
1000impl ValueType for Box<str> {
1001    type Type = String;
1002}
1003
1004impl ValueTypeOptional for Box<str> {}
1005
1006unsafe impl<'a> FromValue<'a> for Box<str> {
1007    type Checker = GenericValueTypeOrNoneChecker<Self>;
1008
1009    unsafe fn from_value(value: &'a Value) -> Self {
1010        Box::<str>::from(<&str>::from_value(value))
1011    }
1012}
1013
1014impl StaticType for Box<str> {
1015    fn static_type() -> Type {
1016        String::static_type()
1017    }
1018}
1019
1020impl ToValue for Box<str> {
1021    fn to_value(&self) -> Value {
1022        <&str>::to_value(&self.as_ref())
1023    }
1024
1025    fn value_type(&self) -> Type {
1026        String::static_type()
1027    }
1028}
1029
1030impl From<Box<str>> for Value {
1031    #[inline]
1032    fn from(s: Box<str>) -> Self {
1033        s.to_value()
1034    }
1035}
1036
1037impl ToValueOptional for Box<str> {
1038    fn to_value_optional(s: Option<&Self>) -> Value {
1039        <str>::to_value_optional(s.as_ref().map(|s| s.as_ref()))
1040    }
1041}
1042
1043impl ValueType for Vec<String> {
1044    type Type = Vec<String>;
1045}
1046
1047unsafe impl<'a> FromValue<'a> for Vec<String> {
1048    type Checker = GenericValueTypeChecker<Self>;
1049
1050    unsafe fn from_value(value: &'a Value) -> Self {
1051        let ptr = gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *const *const c_char;
1052        FromGlibPtrContainer::from_glib_none(ptr)
1053    }
1054}
1055
1056impl ToValue for Vec<String> {
1057    fn to_value(&self) -> Value {
1058        unsafe {
1059            let mut value = Value::for_value_type::<Self>();
1060            let ptr: *mut *mut c_char = self.to_glib_full();
1061            gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, ptr as *const c_void);
1062            value
1063        }
1064    }
1065
1066    fn value_type(&self) -> Type {
1067        <Vec<String>>::static_type()
1068    }
1069}
1070
1071impl From<Vec<String>> for Value {
1072    #[inline]
1073    fn from(s: Vec<String>) -> Self {
1074        s.to_value()
1075    }
1076}
1077
1078impl ToValue for [&'_ str] {
1079    fn to_value(&self) -> Value {
1080        unsafe {
1081            let mut value = Value::for_value_type::<Vec<String>>();
1082            let ptr: *mut *mut c_char = self.to_glib_full();
1083            gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, ptr as *const c_void);
1084            value
1085        }
1086    }
1087
1088    fn value_type(&self) -> Type {
1089        <Vec<String>>::static_type()
1090    }
1091}
1092
1093impl ToValue for &'_ [&'_ str] {
1094    fn to_value(&self) -> Value {
1095        unsafe {
1096            let mut value = Value::for_value_type::<Vec<String>>();
1097            let ptr: *mut *mut c_char = self.to_glib_full();
1098            gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, ptr as *const c_void);
1099            value
1100        }
1101    }
1102
1103    fn value_type(&self) -> Type {
1104        <Vec<String>>::static_type()
1105    }
1106}
1107
1108impl ToValue for Path {
1109    fn to_value(&self) -> Value {
1110        unsafe {
1111            let mut value = Value::for_value_type::<PathBuf>();
1112
1113            gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, self.to_glib_full());
1114
1115            value
1116        }
1117    }
1118
1119    fn value_type(&self) -> Type {
1120        PathBuf::static_type()
1121    }
1122}
1123
1124impl ToValue for &Path {
1125    fn to_value(&self) -> Value {
1126        (*self).to_value()
1127    }
1128
1129    fn value_type(&self) -> Type {
1130        PathBuf::static_type()
1131    }
1132}
1133
1134impl ToValueOptional for Path {
1135    fn to_value_optional(s: Option<&Self>) -> Value {
1136        let mut value = Value::for_value_type::<PathBuf>();
1137        unsafe {
1138            gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, s.to_glib_full());
1139        }
1140
1141        value
1142    }
1143}
1144
1145impl ValueType for PathBuf {
1146    type Type = PathBuf;
1147}
1148
1149impl ValueTypeOptional for PathBuf {}
1150
1151unsafe impl<'a> FromValue<'a> for PathBuf {
1152    type Checker = GenericValueTypeOrNoneChecker<Self>;
1153
1154    unsafe fn from_value(value: &'a Value) -> Self {
1155        from_glib_none(gobject_ffi::g_value_get_string(value.to_glib_none().0))
1156    }
1157}
1158
1159impl ToValue for PathBuf {
1160    fn to_value(&self) -> Value {
1161        <&Path>::to_value(&self.as_path())
1162    }
1163
1164    fn value_type(&self) -> Type {
1165        PathBuf::static_type()
1166    }
1167}
1168
1169impl From<PathBuf> for Value {
1170    #[inline]
1171    fn from(s: PathBuf) -> Self {
1172        s.to_value()
1173    }
1174}
1175
1176impl ToValueOptional for PathBuf {
1177    fn to_value_optional(s: Option<&Self>) -> Value {
1178        <Path>::to_value_optional(s.as_ref().map(|s| s.as_path()))
1179    }
1180}
1181
1182impl ValueType for bool {
1183    type Type = Self;
1184}
1185
1186unsafe impl<'a> FromValue<'a> for bool {
1187    type Checker = GenericValueTypeChecker<Self>;
1188
1189    #[inline]
1190    unsafe fn from_value(value: &'a Value) -> Self {
1191        from_glib(gobject_ffi::g_value_get_boolean(value.to_glib_none().0))
1192    }
1193}
1194
1195impl ToValue for bool {
1196    #[inline]
1197    fn to_value(&self) -> Value {
1198        let mut value = Value::for_value_type::<Self>();
1199        unsafe {
1200            gobject_ffi::g_value_set_boolean(&mut value.inner, self.into_glib());
1201        }
1202        value
1203    }
1204
1205    #[inline]
1206    fn value_type(&self) -> Type {
1207        Self::static_type()
1208    }
1209}
1210
1211impl From<bool> for Value {
1212    #[inline]
1213    fn from(v: bool) -> Self {
1214        v.to_value()
1215    }
1216}
1217
1218impl ValueType for Pointer {
1219    type Type = Self;
1220}
1221
1222unsafe impl<'a> FromValue<'a> for Pointer {
1223    type Checker = GenericValueTypeChecker<Self>;
1224
1225    #[inline]
1226    unsafe fn from_value(value: &'a Value) -> Self {
1227        gobject_ffi::g_value_get_pointer(value.to_glib_none().0)
1228    }
1229}
1230
1231impl ToValue for Pointer {
1232    #[inline]
1233    fn to_value(&self) -> Value {
1234        let mut value = Value::for_value_type::<Self>();
1235        unsafe {
1236            gobject_ffi::g_value_set_pointer(&mut value.inner, *self);
1237        }
1238        value
1239    }
1240
1241    #[inline]
1242    fn value_type(&self) -> Type {
1243        <<Self as ValueType>::Type as StaticType>::static_type()
1244    }
1245}
1246
1247impl From<Pointer> for Value {
1248    #[inline]
1249    fn from(v: Pointer) -> Self {
1250        v.to_value()
1251    }
1252}
1253
1254impl ValueType for ptr::NonNull<Pointee> {
1255    type Type = Pointer;
1256}
1257
1258unsafe impl<'a> FromValue<'a> for ptr::NonNull<Pointee> {
1259    type Checker = GenericValueTypeOrNoneChecker<Self>;
1260
1261    #[inline]
1262    unsafe fn from_value(value: &'a Value) -> Self {
1263        ptr::NonNull::new_unchecked(Pointer::from_value(value))
1264    }
1265}
1266
1267impl ToValue for ptr::NonNull<Pointee> {
1268    #[inline]
1269    fn to_value(&self) -> Value {
1270        self.as_ptr().to_value()
1271    }
1272
1273    #[inline]
1274    fn value_type(&self) -> Type {
1275        <<Self as ValueType>::Type as StaticType>::static_type()
1276    }
1277}
1278
1279impl From<ptr::NonNull<Pointee>> for Value {
1280    #[inline]
1281    fn from(v: ptr::NonNull<Pointee>) -> Self {
1282        v.to_value()
1283    }
1284}
1285
1286impl ToValueOptional for ptr::NonNull<Pointee> {
1287    #[inline]
1288    fn to_value_optional(p: Option<&Self>) -> Value {
1289        p.map(|p| p.as_ptr()).unwrap_or(ptr::null_mut()).to_value()
1290    }
1291}
1292
1293macro_rules! numeric {
1294    ($name:ty, $get:expr, $set:expr) => {
1295        impl ValueType for $name {
1296            type Type = Self;
1297        }
1298
1299        unsafe impl<'a> FromValue<'a> for $name {
1300            type Checker = GenericValueTypeChecker<Self>;
1301
1302            #[inline]
1303            #[allow(clippy::redundant_closure_call)]
1304            unsafe fn from_value(value: &'a Value) -> Self {
1305                $get(value.to_glib_none().0)
1306            }
1307        }
1308
1309        impl ToValue for $name {
1310            #[inline]
1311            #[allow(clippy::redundant_closure_call)]
1312            fn to_value(&self) -> Value {
1313                let mut value = Value::for_value_type::<Self>();
1314                unsafe {
1315                    $set(&mut value.inner, *self);
1316                }
1317                value
1318            }
1319
1320            #[inline]
1321            fn value_type(&self) -> Type {
1322                Self::static_type()
1323            }
1324        }
1325
1326        impl From<$name> for Value {
1327            #[inline]
1328            fn from(v: $name) -> Self {
1329                v.to_value()
1330            }
1331        }
1332    };
1333}
1334macro_rules! not_zero {
1335    ($name:ty, $num:ty) => {
1336        impl ValueType for $name {
1337            type Type = $name;
1338        }
1339
1340        unsafe impl<'a> FromValue<'a> for $name {
1341            // Works because it returns `UnexpectedNone` if the value is NULL
1342            // by checking it against `0`.
1343            type Checker = GenericValueTypeOrNoneChecker<Self>;
1344
1345            #[inline]
1346            unsafe fn from_value(value: &'a Value) -> Self {
1347                let res = <$num>::from_value(value);
1348                Self::try_from(res).unwrap()
1349            }
1350        }
1351
1352        impl ToValue for $name {
1353            #[inline]
1354            fn to_value(&self) -> Value {
1355                <$num>::to_value(&<$num>::from(*self))
1356            }
1357
1358            #[inline]
1359            fn value_type(&self) -> Type {
1360                Self::static_type()
1361            }
1362        }
1363
1364        impl From<$name> for Value {
1365            #[inline]
1366            fn from(v: $name) -> Self {
1367                v.to_value()
1368            }
1369        }
1370
1371        impl ToValueOptional for $name {
1372            fn to_value_optional(s: Option<&Self>) -> Value {
1373                match s {
1374                    Some(x) => x.to_value(),
1375                    None => <$num>::to_value(&0),
1376                }
1377            }
1378        }
1379    };
1380}
1381
1382numeric!(
1383    i8,
1384    gobject_ffi::g_value_get_schar,
1385    gobject_ffi::g_value_set_schar
1386);
1387not_zero!(NonZeroI8, i8);
1388numeric!(
1389    u8,
1390    gobject_ffi::g_value_get_uchar,
1391    gobject_ffi::g_value_set_uchar
1392);
1393not_zero!(NonZeroU8, u8);
1394numeric!(
1395    i32,
1396    gobject_ffi::g_value_get_int,
1397    gobject_ffi::g_value_set_int
1398);
1399not_zero!(NonZeroI32, i32);
1400numeric!(
1401    u32,
1402    gobject_ffi::g_value_get_uint,
1403    gobject_ffi::g_value_set_uint
1404);
1405not_zero!(NonZeroU32, u32);
1406numeric!(
1407    i64,
1408    gobject_ffi::g_value_get_int64,
1409    gobject_ffi::g_value_set_int64
1410);
1411not_zero!(NonZeroI64, i64);
1412numeric!(
1413    u64,
1414    gobject_ffi::g_value_get_uint64,
1415    gobject_ffi::g_value_set_uint64
1416);
1417not_zero!(NonZeroU64, u64);
1418numeric!(
1419    crate::ILong,
1420    |v| gobject_ffi::g_value_get_long(v).into(),
1421    |v, i: crate::ILong| gobject_ffi::g_value_set_long(v, i.0)
1422);
1423numeric!(
1424    crate::ULong,
1425    |v| gobject_ffi::g_value_get_ulong(v).into(),
1426    |v, i: crate::ULong| gobject_ffi::g_value_set_ulong(v, i.0)
1427);
1428numeric!(
1429    f32,
1430    gobject_ffi::g_value_get_float,
1431    gobject_ffi::g_value_set_float
1432);
1433numeric!(
1434    f64,
1435    gobject_ffi::g_value_get_double,
1436    gobject_ffi::g_value_set_double
1437);
1438
1439impl ValueType for char {
1440    type Type = u32;
1441}
1442
1443unsafe impl<'a> FromValue<'a> for char {
1444    type Checker = CharTypeChecker;
1445
1446    #[inline]
1447    unsafe fn from_value(value: &'a Value) -> Self {
1448        let res: u32 = gobject_ffi::g_value_get_uint(value.to_glib_none().0);
1449        // safe because the check is done by `Self::Checker`
1450        char::from_u32_unchecked(res)
1451    }
1452}
1453
1454impl ToValue for char {
1455    #[inline]
1456    fn to_value(&self) -> Value {
1457        let mut value = Value::for_value_type::<Self>();
1458        unsafe {
1459            gobject_ffi::g_value_set_uint(&mut value.inner, *self as u32);
1460        }
1461        value
1462    }
1463
1464    #[inline]
1465    fn value_type(&self) -> Type {
1466        crate::Type::U32
1467    }
1468}
1469
1470impl From<char> for Value {
1471    #[inline]
1472    fn from(v: char) -> Self {
1473        v.to_value()
1474    }
1475}
1476
1477// rustdoc-stripper-ignore-next
1478/// A [`Value`] containing another [`Value`].
1479pub struct BoxedValue(pub Value);
1480
1481impl Deref for BoxedValue {
1482    type Target = Value;
1483
1484    #[inline]
1485    fn deref(&self) -> &Value {
1486        &self.0
1487    }
1488}
1489
1490impl ValueType for BoxedValue {
1491    type Type = BoxedValue;
1492}
1493
1494impl ValueTypeOptional for BoxedValue {}
1495
1496unsafe impl<'a> FromValue<'a> for BoxedValue {
1497    type Checker = GenericValueTypeOrNoneChecker<Self>;
1498
1499    #[inline]
1500    unsafe fn from_value(value: &'a Value) -> Self {
1501        let ptr = gobject_ffi::g_value_get_boxed(value.to_glib_none().0);
1502        BoxedValue(from_glib_none(ptr as *const gobject_ffi::GValue))
1503    }
1504}
1505
1506impl ToValue for BoxedValue {
1507    #[inline]
1508    fn to_value(&self) -> Value {
1509        unsafe {
1510            let mut value = Value::for_value_type::<BoxedValue>();
1511
1512            gobject_ffi::g_value_set_boxed(
1513                value.to_glib_none_mut().0,
1514                self.0.to_glib_none().0 as ffi::gconstpointer,
1515            );
1516
1517            value
1518        }
1519    }
1520
1521    #[inline]
1522    fn value_type(&self) -> Type {
1523        BoxedValue::static_type()
1524    }
1525}
1526
1527impl From<BoxedValue> for Value {
1528    #[inline]
1529    fn from(v: BoxedValue) -> Self {
1530        unsafe {
1531            let mut value = Value::for_value_type::<BoxedValue>();
1532
1533            gobject_ffi::g_value_take_boxed(
1534                value.to_glib_none_mut().0,
1535                v.0.to_glib_full() as ffi::gconstpointer,
1536            );
1537
1538            value
1539        }
1540    }
1541}
1542
1543impl ToValueOptional for BoxedValue {
1544    #[inline]
1545    fn to_value_optional(s: Option<&Self>) -> Value {
1546        let mut value = Value::for_value_type::<Self>();
1547        unsafe {
1548            gobject_ffi::g_value_set_boxed(
1549                value.to_glib_none_mut().0,
1550                s.map(|s| &s.0).to_glib_none().0 as ffi::gconstpointer,
1551            );
1552        }
1553
1554        value
1555    }
1556}
1557
1558#[cfg(test)]
1559mod tests {
1560    use std::num::NonZeroI32;
1561
1562    use super::*;
1563
1564    #[test]
1565    fn test_send_value() {
1566        use std::thread;
1567
1568        let v = SendValue::from(&1i32);
1569
1570        // Must compile, while it must fail with Value
1571        thread::spawn(move || drop(v)).join().unwrap();
1572    }
1573
1574    #[test]
1575    fn test_strv() {
1576        let v = ["123", "456"].to_value();
1577        assert_eq!(
1578            v.get::<Vec<GString>>(),
1579            Ok(vec![GString::from("123"), GString::from("456")])
1580        );
1581
1582        let v = vec![String::from("123"), String::from("456")].to_value();
1583        assert_eq!(
1584            v.get::<Vec<GString>>(),
1585            Ok(vec![GString::from("123"), GString::from("456")])
1586        );
1587    }
1588
1589    #[test]
1590    fn test_from_to_value() {
1591        let v = 123.to_value();
1592        assert_eq!(v.get(), Ok(123));
1593        assert_eq!(
1594            v.get::<&str>(),
1595            Err(ValueTypeMismatchError::new(Type::I32, Type::STRING).into())
1596        );
1597        assert_eq!(
1598            v.get::<bool>(),
1599            Err(ValueTypeMismatchError::new(Type::I32, Type::BOOL))
1600        );
1601
1602        // Check if &str / str / Option<&str> etc can be converted and retrieved
1603        let v_str = "test".to_value();
1604        assert_eq!(v_str.get::<&str>(), Ok("test"));
1605        assert_eq!(v_str.get::<Option<&str>>(), Ok(Some("test")));
1606        assert_eq!(
1607            v_str.get::<i32>(),
1608            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1609        );
1610
1611        let some_v = Some("test").to_value();
1612        assert_eq!(some_v.get::<&str>(), Ok("test"));
1613        assert_eq!(some_v.get_owned::<String>(), Ok("test".to_string()));
1614        assert_eq!(
1615            some_v.get_owned::<Option<String>>(),
1616            Ok(Some("test".to_string()))
1617        );
1618        assert_eq!(some_v.get::<Option<&str>>(), Ok(Some("test")));
1619        assert_eq!(
1620            some_v.get::<i32>(),
1621            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1622        );
1623
1624        let none_str: Option<&str> = None;
1625        let none_v = none_str.to_value();
1626        assert_eq!(none_v.get::<Option<&str>>(), Ok(None));
1627        assert_eq!(
1628            none_v.get::<i32>(),
1629            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1630        );
1631
1632        // Check if owned T and Option<T> can be converted and retrieved
1633        let v_str = String::from("test").to_value();
1634        assert_eq!(v_str.get::<String>(), Ok(String::from("test")));
1635        assert_eq!(
1636            v_str.get::<Option<String>>(),
1637            Ok(Some(String::from("test")))
1638        );
1639        assert_eq!(
1640            v_str.get::<i32>(),
1641            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1642        );
1643
1644        let some_v = Some(String::from("test")).to_value();
1645        assert_eq!(some_v.get::<String>(), Ok(String::from("test")));
1646        assert_eq!(
1647            some_v.get::<Option<String>>(),
1648            Ok(Some(String::from("test")))
1649        );
1650        assert_eq!(
1651            some_v.get::<i32>(),
1652            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1653        );
1654
1655        let none_str: Option<String> = None;
1656        let none_v = none_str.to_value();
1657        assert_eq!(none_v.get::<Option<String>>(), Ok(None));
1658        assert_eq!(
1659            none_v.get::<i32>(),
1660            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1661        );
1662
1663        let c_v = 'c'.to_value();
1664        assert_eq!(c_v.get::<char>(), Ok('c'));
1665
1666        let c_v = 0xFFFFFFFFu32.to_value();
1667        assert_eq!(
1668            c_v.get::<char>(),
1669            Err(InvalidCharError::CharConversionError)
1670        );
1671
1672        // Check if &T and Option<&T> can be converted and retrieved
1673        let v_str = String::from("test").to_value();
1674        assert_eq!(v_str.get::<String>(), Ok(String::from("test")));
1675        assert_eq!(
1676            v_str.get::<Option<String>>(),
1677            Ok(Some(String::from("test")))
1678        );
1679        assert_eq!(
1680            v_str.get::<i32>(),
1681            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1682        );
1683
1684        let some_v = Some(&String::from("test")).to_value();
1685        assert_eq!(some_v.get::<String>(), Ok(String::from("test")));
1686        assert_eq!(
1687            some_v.get::<Option<String>>(),
1688            Ok(Some(String::from("test")))
1689        );
1690        assert_eq!(
1691            some_v.get::<i32>(),
1692            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1693        );
1694
1695        let none_str: Option<&String> = None;
1696        let none_v = none_str.to_value();
1697        assert_eq!(none_v.get::<Option<String>>(), Ok(None));
1698        assert_eq!(
1699            none_v.get::<i32>(),
1700            Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1701        );
1702
1703        // Check handling of NonZeroT
1704        let v = NonZeroI32::new(123).unwrap().to_value();
1705        assert_eq!(v.get::<NonZeroI32>(), Ok(NonZeroI32::new(123).unwrap()));
1706
1707        let v = 123i32.to_value();
1708        assert_eq!(v.get::<NonZeroI32>(), Ok(NonZeroI32::new(123).unwrap()));
1709
1710        let v = 0i32.to_value();
1711        assert_eq!(
1712            v.get::<NonZeroI32>(),
1713            Err(ValueTypeMismatchOrNoneError::UnexpectedNone)
1714        );
1715
1716        assert_eq!(v.get::<Option<NonZeroI32>>(), Ok(None));
1717    }
1718
1719    #[test]
1720    fn test_transform() {
1721        let v = 123.to_value();
1722        let v2 = v
1723            .transform::<String>()
1724            .expect("Failed to transform to string");
1725        assert_eq!(v2.get::<&str>(), Ok("123"));
1726    }
1727
1728    #[test]
1729    fn test_into_raw() {
1730        unsafe {
1731            let mut v = 123.to_value().into_raw();
1732            assert_eq!(gobject_ffi::g_type_check_value(&v), ffi::GTRUE);
1733            assert_eq!(gobject_ffi::g_value_get_int(&v), 123);
1734            gobject_ffi::g_value_unset(&mut v);
1735        }
1736    }
1737
1738    #[test]
1739    fn test_debug() {
1740        fn value_debug_string<T: ToValue>(val: T) -> String {
1741            format!("{:?}", val.to_value())
1742        }
1743
1744        assert_eq!(value_debug_string(1u32), "(guint) 1");
1745        assert_eq!(value_debug_string(2i32), "(gint) 2");
1746        assert_eq!(value_debug_string(false), "(gboolean) FALSE");
1747        assert_eq!(value_debug_string("FooBar"), r#"(gchararray) "FooBar""#);
1748    }
1749}
glib/value.rs

glib/
value.rs
