# Module glib::value [−] [src]

`Value` binding and helper traits.

The type of a `Value` is dynamic in that it generally isn't known at compile time but once created a `Value` can't change its type.

`TypedValue` has a statically known type and dereferences to `Value` so it can be used everywhere `Value` references are accepted.

Supported types are `bool`, `i8`, `u8`, `i32`, `u32`, `i64`, `u64`, `f32`, `f64`, `String` and objects (`T: IsA<Object>`).

# Examples

    use glib::prelude::*; // or `use gtk::prelude::*;`
    use glib::{TypedValue, Value};

    // Value and TypedValue implement From<&i32>, From<&str>
    // and From<Option<&str>>. Another option is the `ToValue` trait.
    let mut num = 10.to_value();
    let mut hello = Value::from("Hello!");
    let none: Option<&str> = None;
    let str_none = Value::from(none.clone());
    let typed_str_none = TypedValue::from(none);

    // `is` tests the type of the value.
    assert!(num.is::<i32>());
    assert!(hello.is::<String>());

    // `get` tries to get a value of specific type and returns None
    // if the type doesn't match or the value is None.
    assert_eq!(num.get(), Some(10));
    assert_eq!(num.get::<String>(), None);
    assert_eq!(hello.get(), Some(String::from("Hello!")));
    assert_eq!(hello.get::<String>(), Some(String::from("Hello!")));
    assert_eq!(str_none.get::<String>(), None);

    // `typed` tries to convert a `Value` to `TypedValue`.
    let mut typed_num = num.downcast::<i32>().unwrap();
    let mut typed_hello = hello.downcast::<String>().unwrap();

    // `str_none` is not an `i32`
    assert!(str_none.downcast::<i32>().is_err());

    // `get`
    assert!(typed_hello.get().unwrap() == "Hello!");
    assert!(typed_str_none.get() == None);

    // Numeric types can't have value `None`, `get` always returns `Some`.
    // Such types have `get_some`, which avoids unnecessary `unwrap`ping.
    assert_eq!(typed_num.get().unwrap(), 10);
    assert_eq!(typed_num.get_some(), 10);

    // `set_none` sets the value to `None` if the type supports it.
    typed_hello.set_none();
    assert!(typed_hello.get().is_none());

    // `set` takes an optional reference for types that support `None`.
    typed_hello.set(Some("Hello again!"));
    assert!(typed_hello.get().unwrap() == "Hello again!");

    // `set_some` is the only setter for types that don't support `None`.
    typed_num.set_some(&20);
    assert_eq!(typed_num.get_some(), 20);

## Structs

TypedValue | A statically typed `Value`.
Value | A generic value capable of carrying various types.
ValueArray |

## Traits

FromValue | Extracts a value.
FromValueOptional | Extracts a value.
SetValue | Sets a value.
SetValueOptional | Sets a value.
ToValue | Converts to `Value`.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
↑
  Move up in search results
↓
  Move down in search results
↹
  Switch tab
⏎
  Go to active search result
+ / -
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)