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> dynFromValue<'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> dynFromValue<'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 actual: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: u32 = 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: &ValueTypeMismatchError) => 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) => <E as fmt::Display>::fmt(self: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: E)) => 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: E)) => {
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) => 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: &&&T| **s))
441 }
442}
443
444#[inline]
445unsafe fn copy_value(value: *const gobject_ffi::GValue) -> *mut gobject_ffi::GValue {
446 let copy: *mut GValue = ffi::g_malloc0(n_bytes:mem::size_of::<gobject_ffi::GValue>()) as *mut gobject_ffi::GValue;
447 copy_into_value(dest:copy, src:value);
448 copy
449}
450
451#[inline]
452unsafe fn free_value(value: *mut gobject_ffi::GValue) {
453 clear_value(value);
454 ffi::g_free(mem:value as *mut _);
455}
456
457#[inline]
458unsafe fn init_value(value: *mut gobject_ffi::GValue) {
459 ptr::write(dst:value, src: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(value: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 #[doc(alias = "GValue")]
492 pub struct Value(BoxedInline<gobject_ffi::GValue>);
493
494 match fn {
495 copy => |ptr| copy_value(ptr),
496 free => |ptr| free_value(ptr),
497 init => |ptr| init_value(ptr),
498 copy_into => |dest, src| copy_into_value(dest, src),
499 clear => |ptr| clear_value(ptr),
500 }
501}
502
503impl Value {
504 // rustdoc-stripper-ignore-next
505 /// Creates a new `Value` that is initialized with `type_`.
506 ///
507 /// # Panics
508 ///
509 /// If `type_` can't be stored in a `Value` this function panics.
510 pub fn from_type(type_: Type) -> Self {
511 unsafe {
512 assert_eq!(
513 gobject_ffi::g_type_check_is_value_type(type_.into_glib()),
514 ffi::GTRUE
515 );
516 Self::from_type_unchecked(type_)
517 }
518 }
519
520 // rustdoc-stripper-ignore-next
521 /// Creates a new `Value` that is initialized with `type_`.
522 ///
523 /// # SAFETY
524 ///
525 /// This must be called with a valid `type_` that can be stored in `Value`s.
526 #[inline]
527 pub unsafe fn from_type_unchecked(type_: Type) -> Self {
528 unsafe {
529 let mut value = Value::uninitialized();
530 gobject_ffi::g_value_init(value.to_glib_none_mut().0, type_.into_glib());
531 value
532 }
533 }
534
535 // rustdoc-stripper-ignore-next
536 /// Creates a new `Value` that is initialized for a given `ValueType`.
537 #[inline]
538 pub fn for_value_type<T: ValueType>() -> Self {
539 unsafe { Value::from_type_unchecked(T::Type::static_type()) }
540 }
541
542 // rustdoc-stripper-ignore-next
543 /// Creates a new `String`-typed `Value` from a `'static` string.
544 #[inline]
545 #[doc(alias = "g_value_set_static_string")]
546 pub fn from_static_str(s: &'static GStr) -> Self {
547 unsafe {
548 let mut v = Self::from_type_unchecked(Type::STRING);
549 gobject_ffi::g_value_set_static_string(v.to_glib_none_mut().0, s.as_ptr());
550 v
551 }
552 }
553
554 #[cfg(feature = "v2_66")]
555 #[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
556 // rustdoc-stripper-ignore-next
557 /// Creates a new `String`-typed `Value` from a `'static` string that is also assumed to be
558 /// interned.
559 #[inline]
560 #[doc(alias = "g_value_set_interned_string")]
561 pub fn from_interned_str(s: &'static GStr) -> Self {
562 unsafe {
563 let mut v = Self::from_type_unchecked(Type::STRING);
564 gobject_ffi::g_value_set_interned_string(v.to_glib_none_mut().0, s.as_ptr());
565 v
566 }
567 }
568
569 // rustdoc-stripper-ignore-next
570 /// Tries to get a value of type `T`.
571 ///
572 /// Returns `Ok` if the type is correct.
573 #[inline]
574 pub fn get<'a, T>(
575 &'a self,
576 ) -> Result<T, <<T as FromValue<'a>>::Checker as ValueTypeChecker>::Error>
577 where
578 T: FromValue<'a>,
579 {
580 unsafe {
581 T::Checker::check(self)?;
582 Ok(T::from_value(self))
583 }
584 }
585
586 // rustdoc-stripper-ignore-next
587 /// Tries to get a value of an owned type `T`.
588 #[inline]
589 pub fn get_owned<T>(&self) -> Result<T, <<T as FromValue>::Checker as ValueTypeChecker>::Error>
590 where
591 T: for<'b> FromValue<'b> + 'static,
592 {
593 unsafe {
594 T::Checker::check(self)?;
595 Ok(FromValue::from_value(self))
596 }
597 }
598
599 // rustdoc-stripper-ignore-next
600 /// Returns `true` if the type of the value corresponds to `T`
601 /// or is a sub-type of `T`.
602 #[inline]
603 pub fn is<T: StaticType>(&self) -> bool {
604 self.is_type(T::static_type())
605 }
606
607 // rustdoc-stripper-ignore-next
608 /// Returns `true` if the type of the value corresponds to `type_`
609 /// or is a sub-type of `type_`.
610 #[inline]
611 pub fn is_type(&self, type_: Type) -> bool {
612 self.type_().is_a(type_)
613 }
614
615 // rustdoc-stripper-ignore-next
616 /// Returns the type of the value.
617 #[inline]
618 pub fn type_(&self) -> Type {
619 unsafe { from_glib(self.inner.g_type) }
620 }
621
622 // rustdoc-stripper-ignore-next
623 /// Returns whether `Value`s of type `src` can be transformed to type `dst`.
624 #[doc(alias = "g_value_type_transformable")]
625 pub fn type_transformable(src: Type, dst: Type) -> bool {
626 unsafe {
627 from_glib(gobject_ffi::g_value_type_transformable(
628 src.into_glib(),
629 dst.into_glib(),
630 ))
631 }
632 }
633
634 // rustdoc-stripper-ignore-next
635 /// Tries to transform the value into a value of the target type
636 #[doc(alias = "g_value_transform")]
637 pub fn transform<T: ValueType>(&self) -> Result<Value, crate::BoolError> {
638 self.transform_with_type(T::Type::static_type())
639 }
640
641 // rustdoc-stripper-ignore-next
642 /// Tries to transform the value into a value of the target type
643 #[doc(alias = "g_value_transform")]
644 pub fn transform_with_type(&self, type_: Type) -> Result<Value, crate::BoolError> {
645 unsafe {
646 let mut dest = Value::from_type(type_);
647 if from_glib(gobject_ffi::g_value_transform(
648 self.to_glib_none().0,
649 dest.to_glib_none_mut().0,
650 )) {
651 Ok(dest)
652 } else {
653 Err(crate::bool_error!(
654 "Can't transform value of type '{}' into '{}'",
655 self.type_(),
656 type_
657 ))
658 }
659 }
660 }
661
662 // rustdoc-stripper-ignore-next
663 /// Consumes `Value` and returns the corresponding `GValue`.
664 #[inline]
665 pub fn into_raw(self) -> gobject_ffi::GValue {
666 unsafe {
667 let s = mem::ManuallyDrop::new(self);
668 ptr::read(&s.inner)
669 }
670 }
671
672 // rustdoc-stripper-ignore-next
673 /// Converts a `Value` into a `SendValue`. This fails if `self` does not store a value of type
674 /// `T`. It is required for `T` to be `Send` to call this function.
675 #[inline]
676 pub fn try_into_send_value<T: Send + StaticType>(self) -> Result<SendValue, Self> {
677 if self.type_().is_a(T::static_type()) {
678 unsafe { Ok(SendValue::unsafe_from(self.into_raw())) }
679 } else {
680 Err(self)
681 }
682 }
683
684 // rustdoc-stripper-ignore-next
685 /// Converts a `Value` into a `SendValue`.
686 ///
687 /// # Safety
688 ///
689 /// The type of the value contained in `self` must be `Send`.
690 #[inline]
691 pub unsafe fn into_send_value(self) -> SendValue {
692 SendValue::unsafe_from(self.into_raw())
693 }
694
695 fn content_debug_string(&self) -> GString {
696 unsafe { from_glib_full(gobject_ffi::g_strdup_value_contents(self.to_glib_none().0)) }
697 }
698}
699
700impl fmt::Debug for Value {
701 fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
702 write!(f, "({}) {}", self.type_(), self.content_debug_string())
703 }
704}
705
706impl<'a, T: ?Sized + ToValue> From<&'a T> for Value {
707 #[inline]
708 fn from(value: &'a T) -> Self {
709 value.to_value()
710 }
711}
712
713impl From<SendValue> for Value {
714 #[inline]
715 fn from(value: SendValue) -> Self {
716 unsafe { Value::unsafe_from(value.into_raw()) }
717 }
718}
719
720impl ToValue for Value {
721 #[inline]
722 fn to_value(&self) -> Value {
723 self.clone()
724 }
725
726 #[inline]
727 fn value_type(&self) -> Type {
728 self.type_()
729 }
730}
731
732impl ToValue for &Value {
733 #[inline]
734 fn to_value(&self) -> Value {
735 (*self).clone()
736 }
737
738 #[inline]
739 fn value_type(&self) -> Type {
740 self.type_()
741 }
742}
743
744pub struct NopChecker;
745
746unsafe impl ValueTypeChecker for NopChecker {
747 type Error = Infallible;
748
749 #[inline]
750 fn check(_value: &Value) -> Result<(), Self::Error> {
751 Ok(())
752 }
753}
754
755unsafe impl<'a> FromValue<'a> for Value {
756 type Checker = NopChecker;
757
758 #[inline]
759 unsafe fn from_value(value: &'a Value) -> Self {
760 value.clone()
761 }
762}
763
764unsafe impl<'a> FromValue<'a> for &'a Value {
765 type Checker = NopChecker;
766
767 #[inline]
768 unsafe fn from_value(value: &'a Value) -> Self {
769 value
770 }
771}
772
773impl ToValue for SendValue {
774 #[inline]
775 fn to_value(&self) -> Value {
776 unsafe { from_glib_none(self.to_glib_none().0) }
777 }
778
779 #[inline]
780 fn value_type(&self) -> Type {
781 self.type_()
782 }
783}
784
785impl ToValue for &SendValue {
786 #[inline]
787 fn to_value(&self) -> Value {
788 unsafe { from_glib_none(self.to_glib_none().0) }
789 }
790
791 #[inline]
792 fn value_type(&self) -> Type {
793 self.type_()
794 }
795}
796
797impl StaticType for BoxedValue {
798 #[inline]
799 fn static_type() -> Type {
800 unsafe { from_glib(val:gobject_ffi::g_value_get_type()) }
801 }
802}
803
804crate::wrapper! {
805 // rustdoc-stripper-ignore-next
806 /// A version of [`Value`](struct.Value.html) for storing `Send` types, that implements Send
807 /// itself.
808 ///
809 /// See the [module documentation](index.html) for more details.
810 #[doc(alias = "GValue")]
811 pub struct SendValue(BoxedInline<gobject_ffi::GValue>);
812
813 match fn {
814 copy => |ptr| copy_value(ptr),
815 free => |ptr| free_value(ptr),
816 init => |ptr| init_value(ptr),
817 copy_into => |dest, src| copy_into_value(dest, src),
818 clear => |ptr| clear_value(ptr),
819 }
820}
821
822unsafe impl Send for SendValue {}
823
824impl SendValue {
825 // rustdoc-stripper-ignore-next
826 /// Consumes `SendValue` and returns the corresponding `GValue`.
827 #[inline]
828 pub fn into_raw(self) -> gobject_ffi::GValue {
829 unsafe {
830 let s: ManuallyDrop = mem::ManuallyDrop::new(self);
831 ptr::read(&s.inner)
832 }
833 }
834 #[inline]
835 pub fn from_owned<T: Send + Into<Value>>(t: T) -> Self {
836 unsafe { Self::unsafe_from(t.into().into_raw()) }
837 }
838}
839
840impl fmt::Debug for SendValue {
841 fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
842 write!(f, "({}) {}", self.type_(), self.content_debug_string())
843 }
844}
845
846impl Deref for SendValue {
847 type Target = Value;
848
849 #[inline]
850 fn deref(&self) -> &Value {
851 unsafe { &*(self as *const SendValue as *const Value) }
852 }
853}
854
855impl<'a, T: ?Sized + ToSendValue> From<&'a T> for SendValue {
856 #[inline]
857 fn from(value: &'a T) -> Self {
858 value.to_send_value()
859 }
860}
861
862// rustdoc-stripper-ignore-next
863/// Converts to `SendValue`.
864pub trait ToSendValue: Send + ToValue {
865 // rustdoc-stripper-ignore-next
866 /// Returns a `SendValue` clone of `self`.
867 fn to_send_value(&self) -> SendValue;
868}
869
870impl<T: Send + ToValue + ?Sized> ToSendValue for T {
871 #[inline]
872 fn to_send_value(&self) -> SendValue {
873 unsafe { SendValue::unsafe_from(self.to_value().into_raw()) }
874 }
875}
876
877unsafe impl<'a> FromValue<'a> for &'a str {
878 type Checker = GenericValueTypeOrNoneChecker<Self>;
879
880 #[inline]
881 unsafe fn from_value(value: &'a Value) -> Self {
882 let ptr: *const {unknown} = gobject_ffi::g_value_get_string(value.to_glib_none().0);
883 CStr::from_ptr(ptr).to_str().expect(msg:"Invalid UTF-8")
884 }
885}
886
887impl ToValue for str {
888 fn to_value(&self) -> Value {
889 unsafe {
890 let mut value: Value = Value::for_value_type::<String>();
891
892 gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, self.to_glib_full());
893
894 value
895 }
896 }
897
898 fn value_type(&self) -> Type {
899 String::static_type()
900 }
901}
902
903impl ToValue for &str {
904 fn to_value(&self) -> Value {
905 (*self).to_value()
906 }
907
908 fn value_type(&self) -> Type {
909 String::static_type()
910 }
911}
912
913impl ToValueOptional for str {
914 fn to_value_optional(s: Option<&Self>) -> Value {
915 let mut value: Value = Value::for_value_type::<String>();
916 unsafe {
917 gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, v_string:s.to_glib_full());
918 }
919
920 value
921 }
922}
923
924impl ValueType for String {
925 type Type = String;
926}
927
928impl ValueTypeOptional for String {}
929
930unsafe impl<'a> FromValue<'a> for String {
931 type Checker = GenericValueTypeOrNoneChecker<Self>;
932
933 unsafe fn from_value(value: &'a Value) -> Self {
934 String::from(<&str>::from_value(value))
935 }
936}
937
938impl ToValue for String {
939 fn to_value(&self) -> Value {
940 <&str>::to_value(&self.as_str())
941 }
942
943 fn value_type(&self) -> Type {
944 String::static_type()
945 }
946}
947
948impl From<String> for Value {
949 #[inline]
950 fn from(s: String) -> Self {
951 s.to_value()
952 }
953}
954
955impl ToValueOptional for String {
956 fn to_value_optional(s: Option<&Self>) -> Value {
957 <str>::to_value_optional(s.as_ref().map(|s: &&String| s.as_str()))
958 }
959}
960
961impl ValueType for Box<str> {
962 type Type = String;
963}
964
965impl ValueTypeOptional for Box<str> {}
966
967unsafe impl<'a> FromValue<'a> for Box<str> {
968 type Checker = GenericValueTypeOrNoneChecker<Self>;
969
970 unsafe fn from_value(value: &'a Value) -> Self {
971 Box::<str>::from(<&str>::from_value(value))
972 }
973}
974
975impl StaticType for Box<str> {
976 fn static_type() -> Type {
977 String::static_type()
978 }
979}
980
981impl ToValue for Box<str> {
982 fn to_value(&self) -> Value {
983 <&str>::to_value(&self.as_ref())
984 }
985
986 fn value_type(&self) -> Type {
987 String::static_type()
988 }
989}
990
991impl From<Box<str>> for Value {
992 #[inline]
993 fn from(s: Box<str>) -> Self {
994 s.to_value()
995 }
996}
997
998impl ToValueOptional for Box<str> {
999 fn to_value_optional(s: Option<&Self>) -> Value {
1000 <str>::to_value_optional(s.as_ref().map(|s: &&Box| s.as_ref()))
1001 }
1002}
1003
1004impl ValueType for Vec<String> {
1005 type Type = Vec<String>;
1006}
1007
1008unsafe impl<'a> FromValue<'a> for Vec<String> {
1009 type Checker = GenericValueTypeChecker<Self>;
1010
1011 unsafe fn from_value(value: &'a Value) -> Self {
1012 let ptr: *const *const i8 = gobject_ffi::g_value_get_boxed(value.to_glib_none().0) as *const *const c_char;
1013 FromGlibPtrContainer::from_glib_none(ptr)
1014 }
1015}
1016
1017impl ToValue for Vec<String> {
1018 fn to_value(&self) -> Value {
1019 unsafe {
1020 let mut value: Value = Value::for_value_type::<Self>();
1021 let ptr: *mut *mut c_char = self.to_glib_full();
1022 gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, v_boxed:ptr as *const c_void);
1023 value
1024 }
1025 }
1026
1027 fn value_type(&self) -> Type {
1028 <Vec<String>>::static_type()
1029 }
1030}
1031
1032impl From<Vec<String>> for Value {
1033 #[inline]
1034 fn from(s: Vec<String>) -> Self {
1035 s.to_value()
1036 }
1037}
1038
1039impl ToValue for [&'_ str] {
1040 fn to_value(&self) -> Value {
1041 unsafe {
1042 let mut value: Value = Value::for_value_type::<Vec<String>>();
1043 let ptr: *mut *mut c_char = self.to_glib_full();
1044 gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, v_boxed:ptr as *const c_void);
1045 value
1046 }
1047 }
1048
1049 fn value_type(&self) -> Type {
1050 <Vec<String>>::static_type()
1051 }
1052}
1053
1054impl ToValue for &'_ [&'_ str] {
1055 fn to_value(&self) -> Value {
1056 unsafe {
1057 let mut value: Value = Value::for_value_type::<Vec<String>>();
1058 let ptr: *mut *mut c_char = self.to_glib_full();
1059 gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, v_boxed:ptr as *const c_void);
1060 value
1061 }
1062 }
1063
1064 fn value_type(&self) -> Type {
1065 <Vec<String>>::static_type()
1066 }
1067}
1068
1069impl ToValue for Path {
1070 fn to_value(&self) -> Value {
1071 unsafe {
1072 let mut value: Value = Value::for_value_type::<PathBuf>();
1073
1074 gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, self.to_glib_full());
1075
1076 value
1077 }
1078 }
1079
1080 fn value_type(&self) -> Type {
1081 PathBuf::static_type()
1082 }
1083}
1084
1085impl ToValue for &Path {
1086 fn to_value(&self) -> Value {
1087 (*self).to_value()
1088 }
1089
1090 fn value_type(&self) -> Type {
1091 PathBuf::static_type()
1092 }
1093}
1094
1095impl ToValueOptional for Path {
1096 fn to_value_optional(s: Option<&Self>) -> Value {
1097 let mut value: Value = Value::for_value_type::<PathBuf>();
1098 unsafe {
1099 gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, v_string:s.to_glib_full());
1100 }
1101
1102 value
1103 }
1104}
1105
1106impl ValueType for PathBuf {
1107 type Type = PathBuf;
1108}
1109
1110impl ValueTypeOptional for PathBuf {}
1111
1112unsafe impl<'a> FromValue<'a> for PathBuf {
1113 type Checker = GenericValueTypeOrNoneChecker<Self>;
1114
1115 unsafe fn from_value(value: &'a Value) -> Self {
1116 from_glib_none(ptr:gobject_ffi::g_value_get_string(value.to_glib_none().0))
1117 }
1118}
1119
1120impl ToValue for PathBuf {
1121 fn to_value(&self) -> Value {
1122 <&Path>::to_value(&self.as_path())
1123 }
1124
1125 fn value_type(&self) -> Type {
1126 PathBuf::static_type()
1127 }
1128}
1129
1130impl From<PathBuf> for Value {
1131 #[inline]
1132 fn from(s: PathBuf) -> Self {
1133 s.to_value()
1134 }
1135}
1136
1137impl ToValueOptional for PathBuf {
1138 fn to_value_optional(s: Option<&Self>) -> Value {
1139 <Path>::to_value_optional(s.as_ref().map(|s: &&PathBuf| s.as_path()))
1140 }
1141}
1142
1143impl ValueType for bool {
1144 type Type = Self;
1145}
1146
1147unsafe impl<'a> FromValue<'a> for bool {
1148 type Checker = GenericValueTypeChecker<Self>;
1149
1150 #[inline]
1151 unsafe fn from_value(value: &'a Value) -> Self {
1152 from_glib(val:gobject_ffi::g_value_get_boolean(value.to_glib_none().0))
1153 }
1154}
1155
1156impl ToValue for bool {
1157 #[inline]
1158 fn to_value(&self) -> Value {
1159 let mut value: Value = Value::for_value_type::<Self>();
1160 unsafe {
1161 gobject_ffi::g_value_set_boolean(&mut value.inner, self.into_glib());
1162 }
1163 value
1164 }
1165
1166 #[inline]
1167 fn value_type(&self) -> Type {
1168 Self::static_type()
1169 }
1170}
1171
1172impl From<bool> for Value {
1173 #[inline]
1174 fn from(v: bool) -> Self {
1175 v.to_value()
1176 }
1177}
1178
1179impl ValueType for Pointer {
1180 type Type = Self;
1181}
1182
1183unsafe impl<'a> FromValue<'a> for Pointer {
1184 type Checker = GenericValueTypeChecker<Self>;
1185
1186 #[inline]
1187 unsafe fn from_value(value: &'a Value) -> Self {
1188 gobject_ffi::g_value_get_pointer(value.to_glib_none().0)
1189 }
1190}
1191
1192impl ToValue for Pointer {
1193 #[inline]
1194 fn to_value(&self) -> Value {
1195 let mut value: Value = Value::for_value_type::<Self>();
1196 unsafe {
1197 gobject_ffi::g_value_set_pointer(&mut value.inner, *self);
1198 }
1199 value
1200 }
1201
1202 #[inline]
1203 fn value_type(&self) -> Type {
1204 <<Self as ValueType>::Type as StaticType>::static_type()
1205 }
1206}
1207
1208impl From<Pointer> for Value {
1209 #[inline]
1210 fn from(v: Pointer) -> Self {
1211 v.to_value()
1212 }
1213}
1214
1215impl ValueType for ptr::NonNull<Pointee> {
1216 type Type = Pointer;
1217}
1218
1219unsafe impl<'a> FromValue<'a> for ptr::NonNull<Pointee> {
1220 type Checker = GenericValueTypeOrNoneChecker<Self>;
1221
1222 #[inline]
1223 unsafe fn from_value(value: &'a Value) -> Self {
1224 ptr::NonNull::new_unchecked(ptr:Pointer::from_value(value))
1225 }
1226}
1227
1228impl ToValue for ptr::NonNull<Pointee> {
1229 #[inline]
1230 fn to_value(&self) -> Value {
1231 self.as_ptr().to_value()
1232 }
1233
1234 #[inline]
1235 fn value_type(&self) -> Type {
1236 <<Self as ValueType>::Type as StaticType>::static_type()
1237 }
1238}
1239
1240impl From<ptr::NonNull<Pointee>> for Value {
1241 #[inline]
1242 fn from(v: ptr::NonNull<Pointee>) -> Self {
1243 v.to_value()
1244 }
1245}
1246
1247impl ToValueOptional for ptr::NonNull<Pointee> {
1248 #[inline]
1249 fn to_value_optional(p: Option<&Self>) -> Value {
1250 p.map(|p| p.as_ptr()).unwrap_or(default:ptr::null_mut()).to_value()
1251 }
1252}
1253
1254macro_rules! numeric {
1255 ($name:ty, $get:expr, $set:expr) => {
1256 impl ValueType for $name {
1257 type Type = Self;
1258 }
1259
1260 unsafe impl<'a> FromValue<'a> for $name {
1261 type Checker = GenericValueTypeChecker<Self>;
1262
1263 #[inline]
1264 #[allow(clippy::redundant_closure_call)]
1265 unsafe fn from_value(value: &'a Value) -> Self {
1266 $get(value.to_glib_none().0)
1267 }
1268 }
1269
1270 impl ToValue for $name {
1271 #[inline]
1272 #[allow(clippy::redundant_closure_call)]
1273 fn to_value(&self) -> Value {
1274 let mut value = Value::for_value_type::<Self>();
1275 unsafe {
1276 $set(&mut value.inner, *self);
1277 }
1278 value
1279 }
1280
1281 #[inline]
1282 fn value_type(&self) -> Type {
1283 Self::static_type()
1284 }
1285 }
1286
1287 impl From<$name> for Value {
1288 #[inline]
1289 fn from(v: $name) -> Self {
1290 v.to_value()
1291 }
1292 }
1293 };
1294}
1295macro_rules! not_zero {
1296 ($name:ty, $num:ty) => {
1297 impl ValueType for $name {
1298 type Type = $name;
1299 }
1300
1301 unsafe impl<'a> FromValue<'a> for $name {
1302 // Works because it returns `UnexpectedNone` if the value is NULL
1303 // by checking it against `0`.
1304 type Checker = GenericValueTypeOrNoneChecker<Self>;
1305
1306 #[inline]
1307 unsafe fn from_value(value: &'a Value) -> Self {
1308 let res = <$num>::from_value(value);
1309 Self::try_from(res).unwrap()
1310 }
1311 }
1312
1313 impl ToValue for $name {
1314 #[inline]
1315 fn to_value(&self) -> Value {
1316 <$num>::to_value(&<$num>::from(*self))
1317 }
1318
1319 #[inline]
1320 fn value_type(&self) -> Type {
1321 Self::static_type()
1322 }
1323 }
1324
1325 impl From<$name> for Value {
1326 #[inline]
1327 fn from(v: $name) -> Self {
1328 v.to_value()
1329 }
1330 }
1331
1332 impl ToValueOptional for $name {
1333 fn to_value_optional(s: Option<&Self>) -> Value {
1334 match s {
1335 Some(x) => x.to_value(),
1336 None => <$num>::to_value(&0),
1337 }
1338 }
1339 }
1340 };
1341}
1342
1343numeric!(
1344 i8,
1345 gobject_ffi::g_value_get_schar,
1346 gobject_ffi::g_value_set_schar
1347);
1348not_zero!(NonZeroI8, i8);
1349numeric!(
1350 u8,
1351 gobject_ffi::g_value_get_uchar,
1352 gobject_ffi::g_value_set_uchar
1353);
1354not_zero!(NonZeroU8, u8);
1355numeric!(
1356 i32,
1357 gobject_ffi::g_value_get_int,
1358 gobject_ffi::g_value_set_int
1359);
1360not_zero!(NonZeroI32, i32);
1361numeric!(
1362 u32,
1363 gobject_ffi::g_value_get_uint,
1364 gobject_ffi::g_value_set_uint
1365);
1366not_zero!(NonZeroU32, u32);
1367numeric!(
1368 i64,
1369 gobject_ffi::g_value_get_int64,
1370 gobject_ffi::g_value_set_int64
1371);
1372not_zero!(NonZeroI64, i64);
1373numeric!(
1374 u64,
1375 gobject_ffi::g_value_get_uint64,
1376 gobject_ffi::g_value_set_uint64
1377);
1378not_zero!(NonZeroU64, u64);
1379numeric!(
1380 crate::ILong,
1381 |v| gobject_ffi::g_value_get_long(v).into(),
1382 |v, i: crate::ILong| gobject_ffi::g_value_set_long(v, i.0)
1383);
1384numeric!(
1385 crate::ULong,
1386 |v| gobject_ffi::g_value_get_ulong(v).into(),
1387 |v, i: crate::ULong| gobject_ffi::g_value_set_ulong(v, i.0)
1388);
1389numeric!(
1390 f32,
1391 gobject_ffi::g_value_get_float,
1392 gobject_ffi::g_value_set_float
1393);
1394numeric!(
1395 f64,
1396 gobject_ffi::g_value_get_double,
1397 gobject_ffi::g_value_set_double
1398);
1399
1400impl ValueType for char {
1401 type Type = u32;
1402}
1403
1404unsafe impl<'a> FromValue<'a> for char {
1405 type Checker = CharTypeChecker;
1406
1407 #[inline]
1408 unsafe fn from_value(value: &'a Value) -> Self {
1409 let res: u32 = gobject_ffi::g_value_get_uint(value.to_glib_none().0);
1410 // safe because the check is done by `Self::Checker`
1411 char::from_u32_unchecked(res)
1412 }
1413}
1414
1415impl ToValue for char {
1416 #[inline]
1417 fn to_value(&self) -> Value {
1418 let mut value: Value = Value::for_value_type::<Self>();
1419 unsafe {
1420 gobject_ffi::g_value_set_uint(&mut value.inner, *self as u32);
1421 }
1422 value
1423 }
1424
1425 #[inline]
1426 fn value_type(&self) -> Type {
1427 crate::Type::U32
1428 }
1429}
1430
1431impl From<char> for Value {
1432 #[inline]
1433 fn from(v: char) -> Self {
1434 v.to_value()
1435 }
1436}
1437
1438// rustdoc-stripper-ignore-next
1439/// A [`Value`] containing another [`Value`].
1440pub struct BoxedValue(pub Value);
1441
1442impl Deref for BoxedValue {
1443 type Target = Value;
1444
1445 #[inline]
1446 fn deref(&self) -> &Value {
1447 &self.0
1448 }
1449}
1450
1451impl ValueType for BoxedValue {
1452 type Type = BoxedValue;
1453}
1454
1455impl ValueTypeOptional for BoxedValue {}
1456
1457unsafe impl<'a> FromValue<'a> for BoxedValue {
1458 type Checker = GenericValueTypeOrNoneChecker<Self>;
1459
1460 #[inline]
1461 unsafe fn from_value(value: &'a Value) -> Self {
1462 let ptr: *mut c_void = gobject_ffi::g_value_get_boxed(value.to_glib_none().0);
1463 BoxedValue(from_glib_none(ptr as *const gobject_ffi::GValue))
1464 }
1465}
1466
1467impl ToValue for BoxedValue {
1468 #[inline]
1469 fn to_value(&self) -> Value {
1470 unsafe {
1471 let mut value: Value = Value::for_value_type::<BoxedValue>();
1472
1473 gobject_ffi::g_value_set_boxed(
1474 value.to_glib_none_mut().0,
1475 self.0.to_glib_none().0 as ffi::gconstpointer,
1476 );
1477
1478 value
1479 }
1480 }
1481
1482 #[inline]
1483 fn value_type(&self) -> Type {
1484 BoxedValue::static_type()
1485 }
1486}
1487
1488impl From<BoxedValue> for Value {
1489 #[inline]
1490 fn from(v: BoxedValue) -> Self {
1491 unsafe {
1492 let mut value: Value = Value::for_value_type::<BoxedValue>();
1493
1494 gobject_ffi::g_value_take_boxed(
1495 value.to_glib_none_mut().0,
1496 v_boxed:v.0.to_glib_full() as ffi::gconstpointer,
1497 );
1498
1499 value
1500 }
1501 }
1502}
1503
1504impl ToValueOptional for BoxedValue {
1505 #[inline]
1506 fn to_value_optional(s: Option<&Self>) -> Value {
1507 let mut value: Value = Value::for_value_type::<Self>();
1508 unsafe {
1509 gobject_ffi::g_value_set_boxed(
1510 value.to_glib_none_mut().0,
1511 v_boxed:s.map(|s: &BoxedValue| &s.0).to_glib_none().0 as ffi::gconstpointer,
1512 );
1513 }
1514
1515 value
1516 }
1517}
1518
1519#[cfg(test)]
1520mod tests {
1521 use std::num::NonZeroI32;
1522
1523 use super::*;
1524
1525 #[test]
1526 fn test_send_value() {
1527 use std::thread;
1528
1529 let v = SendValue::from(&1i32);
1530
1531 // Must compile, while it must fail with Value
1532 thread::spawn(move || drop(v)).join().unwrap();
1533 }
1534
1535 #[test]
1536 fn test_strv() {
1537 let v = ["123", "456"].to_value();
1538 assert_eq!(
1539 v.get::<Vec<GString>>(),
1540 Ok(vec![GString::from("123"), GString::from("456")])
1541 );
1542
1543 let v = vec![String::from("123"), String::from("456")].to_value();
1544 assert_eq!(
1545 v.get::<Vec<GString>>(),
1546 Ok(vec![GString::from("123"), GString::from("456")])
1547 );
1548 }
1549
1550 #[test]
1551 fn test_from_to_value() {
1552 let v = 123.to_value();
1553 assert_eq!(v.get(), Ok(123));
1554 assert_eq!(
1555 v.get::<&str>(),
1556 Err(ValueTypeMismatchError::new(Type::I32, Type::STRING).into())
1557 );
1558 assert_eq!(
1559 v.get::<bool>(),
1560 Err(ValueTypeMismatchError::new(Type::I32, Type::BOOL))
1561 );
1562
1563 // Check if &str / str / Option<&str> etc can be converted and retrieved
1564 let v_str = "test".to_value();
1565 assert_eq!(v_str.get::<&str>(), Ok("test"));
1566 assert_eq!(v_str.get::<Option<&str>>(), Ok(Some("test")));
1567 assert_eq!(
1568 v_str.get::<i32>(),
1569 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1570 );
1571
1572 let some_v = Some("test").to_value();
1573 assert_eq!(some_v.get::<&str>(), Ok("test"));
1574 assert_eq!(some_v.get_owned::<String>(), Ok("test".to_string()));
1575 assert_eq!(
1576 some_v.get_owned::<Option<String>>(),
1577 Ok(Some("test".to_string()))
1578 );
1579 assert_eq!(some_v.get::<Option<&str>>(), Ok(Some("test")));
1580 assert_eq!(
1581 some_v.get::<i32>(),
1582 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1583 );
1584
1585 let none_str: Option<&str> = None;
1586 let none_v = none_str.to_value();
1587 assert_eq!(none_v.get::<Option<&str>>(), Ok(None));
1588 assert_eq!(
1589 none_v.get::<i32>(),
1590 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1591 );
1592
1593 // Check if owned T and Option<T> can be converted and retrieved
1594 let v_str = String::from("test").to_value();
1595 assert_eq!(v_str.get::<String>(), Ok(String::from("test")));
1596 assert_eq!(
1597 v_str.get::<Option<String>>(),
1598 Ok(Some(String::from("test")))
1599 );
1600 assert_eq!(
1601 v_str.get::<i32>(),
1602 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1603 );
1604
1605 let some_v = Some(String::from("test")).to_value();
1606 assert_eq!(some_v.get::<String>(), Ok(String::from("test")));
1607 assert_eq!(
1608 some_v.get::<Option<String>>(),
1609 Ok(Some(String::from("test")))
1610 );
1611 assert_eq!(
1612 some_v.get::<i32>(),
1613 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1614 );
1615
1616 let none_str: Option<String> = None;
1617 let none_v = none_str.to_value();
1618 assert_eq!(none_v.get::<Option<String>>(), Ok(None));
1619 assert_eq!(
1620 none_v.get::<i32>(),
1621 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1622 );
1623
1624 let c_v = 'c'.to_value();
1625 assert_eq!(c_v.get::<char>(), Ok('c'));
1626
1627 let c_v = 0xFFFFFFFFu32.to_value();
1628 assert_eq!(
1629 c_v.get::<char>(),
1630 Err(InvalidCharError::CharConversionError)
1631 );
1632
1633 // Check if &T and Option<&T> can be converted and retrieved
1634 let v_str = String::from("test").to_value();
1635 assert_eq!(v_str.get::<String>(), Ok(String::from("test")));
1636 assert_eq!(
1637 v_str.get::<Option<String>>(),
1638 Ok(Some(String::from("test")))
1639 );
1640 assert_eq!(
1641 v_str.get::<i32>(),
1642 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1643 );
1644
1645 let some_v = Some(&String::from("test")).to_value();
1646 assert_eq!(some_v.get::<String>(), Ok(String::from("test")));
1647 assert_eq!(
1648 some_v.get::<Option<String>>(),
1649 Ok(Some(String::from("test")))
1650 );
1651 assert_eq!(
1652 some_v.get::<i32>(),
1653 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1654 );
1655
1656 let none_str: Option<&String> = None;
1657 let none_v = none_str.to_value();
1658 assert_eq!(none_v.get::<Option<String>>(), Ok(None));
1659 assert_eq!(
1660 none_v.get::<i32>(),
1661 Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
1662 );
1663
1664 // Check handling of NonZeroT
1665 let v = NonZeroI32::new(123).unwrap().to_value();
1666 assert_eq!(v.get::<NonZeroI32>(), Ok(NonZeroI32::new(123).unwrap()));
1667
1668 let v = 123i32.to_value();
1669 assert_eq!(v.get::<NonZeroI32>(), Ok(NonZeroI32::new(123).unwrap()));
1670
1671 let v = 0i32.to_value();
1672 assert_eq!(
1673 v.get::<NonZeroI32>(),
1674 Err(ValueTypeMismatchOrNoneError::UnexpectedNone)
1675 );
1676
1677 assert_eq!(v.get::<Option<NonZeroI32>>(), Ok(None));
1678 }
1679
1680 #[test]
1681 fn test_transform() {
1682 let v = 123.to_value();
1683 let v2 = v
1684 .transform::<String>()
1685 .expect("Failed to transform to string");
1686 assert_eq!(v2.get::<&str>(), Ok("123"));
1687 }
1688
1689 #[test]
1690 fn test_into_raw() {
1691 unsafe {
1692 let mut v = 123.to_value().into_raw();
1693 assert_eq!(gobject_ffi::g_type_check_value(&v), ffi::GTRUE);
1694 assert_eq!(gobject_ffi::g_value_get_int(&v), 123);
1695 gobject_ffi::g_value_unset(&mut v);
1696 }
1697 }
1698
1699 #[test]
1700 fn test_debug() {
1701 fn value_debug_string<T: ToValue>(val: T) -> String {
1702 format!("{:?}", val.to_value())
1703 }
1704
1705 assert_eq!(value_debug_string(1u32), "(guint) 1");
1706 assert_eq!(value_debug_string(2i32), "(gint) 2");
1707 assert_eq!(value_debug_string(false), "(gboolean) FALSE");
1708 assert_eq!(value_debug_string("FooBar"), r#"(gchararray) "FooBar""#);
1709 }
1710}
1711