json-glib 0.1.0

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir
// from gtk-girs (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{ffi,Array,NodeType,Object};
use glib::{translate::*};

glib::wrapper! {
    #[derive(Debug, PartialOrd, Ord)]
    pub struct Node(Shared<ffi::JsonNode>);

    match fn {
        ref => |ptr| ffi::json_node_ref(ptr),
        unref => |ptr| ffi::json_node_unref(ptr),
        type_ => || ffi::json_node_get_type(),
    }
}

impl Node {
    #[doc(alias = "json_node_alloc")]
    pub fn alloc() -> Node {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::json_node_alloc())
        }
    }

    #[doc(alias = "json_node_new")]
    pub fn new(type_: NodeType) -> Node {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::json_node_new(type_.into_glib()))
        }
    }

    #[doc(alias = "json_node_copy")]
#[must_use]
    pub fn copy(&self) -> Node {
        unsafe {
            from_glib_full(ffi::json_node_copy(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_dup_array")]
    pub fn dup_array(&self) -> Option<Array> {
        unsafe {
            from_glib_full(ffi::json_node_dup_array(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_dup_object")]
    pub fn dup_object(&self) -> Option<Object> {
        unsafe {
            from_glib_full(ffi::json_node_dup_object(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_dup_string")]
    pub fn dup_string(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::json_node_dup_string(self.to_glib_none().0))
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "json_node_equal")]
     fn equal(&self, b: &Node) -> bool {
        unsafe {
            from_glib(ffi::json_node_equal(ToGlibPtr::<*mut ffi::JsonNode>::to_glib_none(self).0 as glib::ffi::gconstpointer, ToGlibPtr::<*mut ffi::JsonNode>::to_glib_none(b).0 as glib::ffi::gconstpointer))
        }
    }

    #[doc(alias = "json_node_get_array")]
    #[doc(alias = "get_array")]
    pub fn array(&self) -> Option<Array> {
        unsafe {
            from_glib_none(ffi::json_node_get_array(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_get_boolean")]
    #[doc(alias = "get_boolean")]
    pub fn is_boolean(&self) -> bool {
        unsafe {
            from_glib(ffi::json_node_get_boolean(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_get_double")]
    #[doc(alias = "get_double")]
    pub fn double(&self) -> f64 {
        unsafe {
            ffi::json_node_get_double(self.to_glib_none().0)
        }
    }

    #[doc(alias = "json_node_get_int")]
    #[doc(alias = "get_int")]
    pub fn int(&self) -> i64 {
        unsafe {
            ffi::json_node_get_int(self.to_glib_none().0)
        }
    }

    #[doc(alias = "json_node_get_node_type")]
    #[doc(alias = "get_node_type")]
    pub fn node_type(&self) -> NodeType {
        unsafe {
            from_glib(ffi::json_node_get_node_type(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_get_object")]
    #[doc(alias = "get_object")]
    pub fn object(&self) -> Option<Object> {
        unsafe {
            from_glib_none(ffi::json_node_get_object(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_get_parent")]
    #[doc(alias = "get_parent")]
#[must_use]
    pub fn parent(&self) -> Option<Node> {
        unsafe {
            from_glib_none(ffi::json_node_get_parent(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_get_string")]
    #[doc(alias = "get_string")]
    pub fn string(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::json_node_get_string(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_get_value")]
    #[doc(alias = "get_value")]
    pub fn value(&self) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::json_node_get_value(self.to_glib_none().0, value.to_glib_none_mut().0);
            value
        }
    }

    #[doc(alias = "json_node_get_value_type")]
    #[doc(alias = "get_value_type")]
    pub fn value_type(&self) -> glib::types::Type {
        unsafe {
            from_glib(ffi::json_node_get_value_type(self.to_glib_none().0))
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "json_node_hash")]
     fn hash(&self) -> u32 {
        unsafe {
            ffi::json_node_hash(ToGlibPtr::<*mut ffi::JsonNode>::to_glib_none(self).0 as glib::ffi::gconstpointer)
        }
    }

    #[doc(alias = "json_node_init")]
#[must_use]
    pub fn init(&self, type_: NodeType) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init(self.to_glib_none().0, type_.into_glib()))
        }
    }

    #[doc(alias = "json_node_init_array")]
#[must_use]
    pub fn init_array(&self, array: Option<&Array>) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_array(self.to_glib_none().0, array.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_init_boolean")]
#[must_use]
    pub fn init_boolean(&self, value: bool) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_boolean(self.to_glib_none().0, value.into_glib()))
        }
    }

    #[doc(alias = "json_node_init_double")]
#[must_use]
    pub fn init_double(&self, value: f64) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_double(self.to_glib_none().0, value))
        }
    }

    #[doc(alias = "json_node_init_int")]
#[must_use]
    pub fn init_int(&self, value: i64) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_int(self.to_glib_none().0, value))
        }
    }

    #[doc(alias = "json_node_init_null")]
#[must_use]
    pub fn init_null(&self) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_null(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_init_object")]
#[must_use]
    pub fn init_object(&self, object: Option<&Object>) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_object(self.to_glib_none().0, object.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_init_string")]
#[must_use]
    pub fn init_string(&self, value: Option<&str>) -> Node {
        unsafe {
            from_glib_none(ffi::json_node_init_string(self.to_glib_none().0, value.to_glib_none().0))
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "json_node_is_immutable")]
    pub fn is_immutable(&self) -> bool {
        unsafe {
            from_glib(ffi::json_node_is_immutable(self.to_glib_none().0))
        }
    }

    #[doc(alias = "json_node_is_null")]
    pub fn is_null(&self) -> bool {
        unsafe {
            from_glib(ffi::json_node_is_null(self.to_glib_none().0))
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "json_node_seal")]
    pub fn seal(&self) {
        unsafe {
            ffi::json_node_seal(self.to_glib_none().0);
        }
    }

    #[doc(alias = "json_node_set_array")]
    pub fn set_array(&self, array: &Array) {
        unsafe {
            ffi::json_node_set_array(self.to_glib_none().0, array.to_glib_none().0);
        }
    }

    #[doc(alias = "json_node_set_boolean")]
    pub fn set_boolean(&self, value: bool) {
        unsafe {
            ffi::json_node_set_boolean(self.to_glib_none().0, value.into_glib());
        }
    }

    #[doc(alias = "json_node_set_double")]
    pub fn set_double(&self, value: f64) {
        unsafe {
            ffi::json_node_set_double(self.to_glib_none().0, value);
        }
    }

    #[doc(alias = "json_node_set_int")]
    pub fn set_int(&self, value: i64) {
        unsafe {
            ffi::json_node_set_int(self.to_glib_none().0, value);
        }
    }

    #[doc(alias = "json_node_set_object")]
    pub fn set_object(&self, object: Option<&Object>) {
        unsafe {
            ffi::json_node_set_object(self.to_glib_none().0, object.to_glib_none().0);
        }
    }

    #[doc(alias = "json_node_set_parent")]
    pub fn set_parent(&self, parent: Option<&Node>) {
        unsafe {
            ffi::json_node_set_parent(self.to_glib_none().0, parent.to_glib_none().0);
        }
    }

    #[doc(alias = "json_node_set_string")]
    pub fn set_string(&self, value: &str) {
        unsafe {
            ffi::json_node_set_string(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    #[doc(alias = "json_node_set_value")]
    pub fn set_value(&self, value: &glib::Value) {
        unsafe {
            ffi::json_node_set_value(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    #[doc(alias = "json_node_take_array")]
    pub fn take_array(&self, array: Array) {
        unsafe {
            ffi::json_node_take_array(self.to_glib_none().0, array.into_glib_ptr());
        }
    }

    #[doc(alias = "json_node_take_object")]
    pub fn take_object(&self, object: Object) {
        unsafe {
            ffi::json_node_take_object(self.to_glib_none().0, object.into_glib_ptr());
        }
    }

    #[doc(alias = "json_node_type_name")]
    pub fn type_name(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::json_node_type_name(self.to_glib_none().0))
        }
    }
}

#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl PartialEq for Node {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.equal(other)
    }
}
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]

impl Eq for Node {}

#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl std::hash::Hash for Node {
    #[inline]
    fn hash<H>(&self, state: &mut H) where H: std::hash::Hasher {
        std::hash::Hash::hash(&self.hash(), state)
    }
}