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,Node};
use glib::{prelude::*,signal::{connect_raw, SignalHandlerId},translate::*};
use std::{boxed::Box as Box_};

glib::wrapper! {
    #[doc(alias = "JsonReader")]
    pub struct Reader(Object<ffi::JsonReader, ffi::JsonReaderClass>);

    match fn {
        type_ => || ffi::json_reader_get_type(),
    }
}

impl Reader {
        pub const NONE: Option<&'static Reader> = None;
    

    #[doc(alias = "json_reader_new")]
    pub fn new(node: Option<&Node>) -> Reader {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::json_reader_new(node.to_glib_none().0))
        }
    }

            // rustdoc-stripper-ignore-next
            /// Creates a new builder-pattern struct instance to construct [`Reader`] objects.
            ///
            /// This method returns an instance of [`ReaderBuilder`](crate::builders::ReaderBuilder) which can be used to create [`Reader`] objects.
            pub fn builder() -> ReaderBuilder {
                ReaderBuilder::new()
            }
        
}

impl Default for Reader {
                     fn default() -> Self {
                         glib::object::Object::new::<Self>()
                     }
                 }

// rustdoc-stripper-ignore-next
        /// A [builder-pattern] type to construct [`Reader`] objects.
        ///
        /// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct ReaderBuilder {
            builder: glib::object::ObjectBuilder<'static, Reader>,
        }

        impl ReaderBuilder {
        fn new() -> Self {
            Self { builder: glib::object::Object::builder() }
        }

                            pub fn root(self, root: &Node) -> Self {
                            Self { builder: self.builder.property("root", root.clone()), }
                        }

    // rustdoc-stripper-ignore-next
    /// Build the [`Reader`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Reader {
assert_initialized_main_thread!();
    self.builder.build() }
}

pub trait ReaderExt: IsA<Reader> + 'static {
    #[doc(alias = "json_reader_count_elements")]
    fn count_elements(&self) -> i32 {
        unsafe {
            ffi::json_reader_count_elements(self.as_ref().to_glib_none().0)
        }
    }

    #[doc(alias = "json_reader_count_members")]
    fn count_members(&self) -> i32 {
        unsafe {
            ffi::json_reader_count_members(self.as_ref().to_glib_none().0)
        }
    }

    #[doc(alias = "json_reader_end_element")]
    fn end_element(&self) {
        unsafe {
            ffi::json_reader_end_element(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "json_reader_end_member")]
    fn end_member(&self) {
        unsafe {
            ffi::json_reader_end_member(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "json_reader_get_boolean_value")]
    #[doc(alias = "get_boolean_value")]
    fn is_boolean_value(&self) -> bool {
        unsafe {
            from_glib(ffi::json_reader_get_boolean_value(self.as_ref().to_glib_none().0))
        }
    }

    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    #[doc(alias = "json_reader_get_current_node")]
    #[doc(alias = "get_current_node")]
    fn current_node(&self) -> Option<Node> {
        unsafe {
            from_glib_none(ffi::json_reader_get_current_node(self.as_ref().to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_get_double_value")]
    #[doc(alias = "get_double_value")]
    fn double_value(&self) -> f64 {
        unsafe {
            ffi::json_reader_get_double_value(self.as_ref().to_glib_none().0)
        }
    }

    #[doc(alias = "json_reader_get_error")]
    #[doc(alias = "get_error")]
    fn error(&self) -> Option<glib::Error> {
        unsafe {
            from_glib_none(ffi::json_reader_get_error(self.as_ref().to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_get_int_value")]
    #[doc(alias = "get_int_value")]
    fn int_value(&self) -> i64 {
        unsafe {
            ffi::json_reader_get_int_value(self.as_ref().to_glib_none().0)
        }
    }

    #[doc(alias = "json_reader_get_member_name")]
    #[doc(alias = "get_member_name")]
    fn member_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::json_reader_get_member_name(self.as_ref().to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_get_null_value")]
    #[doc(alias = "get_null_value")]
    fn is_null_value(&self) -> bool {
        unsafe {
            from_glib(ffi::json_reader_get_null_value(self.as_ref().to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_get_string_value")]
    #[doc(alias = "get_string_value")]
    fn string_value(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::json_reader_get_string_value(self.as_ref().to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_get_value")]
    #[doc(alias = "get_value")]
    fn value(&self) -> Option<Node> {
        unsafe {
            from_glib_none(ffi::json_reader_get_value(self.as_ref().to_glib_none().0))
        }
    }

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

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

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

    #[doc(alias = "json_reader_list_members")]
    fn list_members(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::json_reader_list_members(self.as_ref().to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_read_element")]
    fn read_element(&self, index_: u32) -> bool {
        unsafe {
            from_glib(ffi::json_reader_read_element(self.as_ref().to_glib_none().0, index_))
        }
    }

    #[doc(alias = "json_reader_read_member")]
    fn read_member(&self, member_name: &str) -> bool {
        unsafe {
            from_glib(ffi::json_reader_read_member(self.as_ref().to_glib_none().0, member_name.to_glib_none().0))
        }
    }

    #[doc(alias = "json_reader_set_root")]
    #[doc(alias = "root")]
    fn set_root(&self, root: Option<&Node>) {
        unsafe {
            ffi::json_reader_set_root(self.as_ref().to_glib_none().0, root.to_glib_none().0);
        }
    }

    fn root(&self) -> Option<Node> {
        ObjectExt::property(self.as_ref(), "root")
    }

    #[doc(alias = "root")]
    fn connect_root_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_root_trampoline<P: IsA<Reader>, F: Fn(&P) + 'static>(this: *mut ffi::JsonReader, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
            let f: &F = &*(f as *const F);
            f(Reader::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, c"notify::root".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_root_trampoline::<Self, F> as *const ())), Box_::into_raw(f))
        }
    }
}

impl<O: IsA<Reader>> ReaderExt for O {}