json_glib/auto/

reader.rs

// 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! {
    /// `JsonReader` provides a simple, cursor-based API for parsing a JSON DOM.
    ///
    /// It is similar, in spirit, to the XML Reader API.
    ///
    /// The cursor is moved by the `json_reader_read_*` and the `json_reader_end_*`
    /// functions. You can enter a JSON object using [`ReaderExt::read_member()`][crate::prelude::ReaderExt::read_member()]
    /// with the name of the object member, access the value at that position, and
    /// move the cursor back one level using [`ReaderExt::end_member()`][crate::prelude::ReaderExt::end_member()]; arrays
    /// work in a similar way, using [`ReaderExt::read_element()`][crate::prelude::ReaderExt::read_element()] with the
    /// index of the element, and using [`ReaderExt::end_element()`][crate::prelude::ReaderExt::end_element()] to move
    /// the cursor back.
    ///
    /// ## Using `JsonReader`
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// g_autoptr(JsonParser) parser = json_parser_new ();
    ///
    /// // str is defined elsewhere and contains:
    /// // { "url" : "http://www.gnome.org/img/flash/two-thirty.png", "size" : [ 652, 242 ] }
    /// json_parser_load_from_data (parser, str, -1, NULL);
    ///
    /// g_autoptr(JsonReader) reader = json_reader_new (json_parser_get_root (parser));
    ///
    /// // Enter the "url" member of the object
    /// json_reader_read_member (reader, "url");
    ///   const char *url = json_reader_get_string_value (reader);
    ///   // url now contains "http://www.gnome.org/img/flash/two-thirty.png"
    ///   json_reader_end_member (reader);
    ///
    /// // Enter the "size" member of the object
    /// json_reader_read_member (reader, "size");
    ///   // Enter the first element of the array
    ///   json_reader_read_element (reader, 0);
    ///     int width = json_reader_get_int_value (reader);
    ///     // width now contains 652
    ///     json_reader_end_element (reader);
    ///   // Enter the second element of the array
    ///   json_reader_read_element (reader, 1);
    ///     int height = json_reader_get_int_value (reader);
    ///     // height now contains 242
    ///     json_reader_end_element (reader);
    ///   json_reader_end_member (reader);
    /// ```
    ///
    /// ## Error handling
    ///
    /// In case of error, `JsonReader` will be set in an error state; all subsequent
    /// calls will simply be ignored until a function that resets the error state is
    /// called, e.g.:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// // ask for the 7th element; if the element does not exist, the
    /// // reader will be put in an error state
    /// json_reader_read_element (reader, 6);
    ///
    /// // in case of error, this will return NULL, otherwise it will
    /// // return the value of the element
    /// str = json_reader_get_string_value (value);
    ///
    /// // this function resets the error state if any was set
    /// json_reader_end_element (reader);
    /// ```
    ///
    /// If you want to detect the error state as soon as possible, you can use
    /// [`ReaderExt::error()`][crate::prelude::ReaderExt::error()]:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// // like the example above, but in this case we print out the
    /// // error immediately
    /// if (!json_reader_read_element (reader, 6))
    ///   {
    ///     const GError *error = json_reader_get_error (reader);
    ///     g_print ("Unable to read the element: %s", error->message);
    ///   }
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `root`
    ///  The root of the JSON tree that the reader should read.
    ///
    /// Readable | Writeable | Construct
    ///
    /// # Implements
    ///
    /// [`ReaderExt`][trait@crate::prelude::ReaderExt], [`trait@glib::ObjectExt`]
    #[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;
    

    /// Creates a new reader.
    ///
    /// You can use this object to read the contents of the JSON tree starting
    /// from the given node.
    /// ## `node`
    /// the root node
    ///
    /// # Returns
    ///
    /// the newly created reader
    #[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() }
        }

                            /// The root of the JSON tree that the reader should read.
                            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() }
}

/// Trait containing all [`struct@Reader`] methods.
///
/// # Implementors
///
/// [`Reader`][struct@crate::Reader]
pub trait ReaderExt: IsA<Reader> + 'static {
    /// Counts the elements of the current position, if the reader is
    /// positioned on an array.
    ///
    /// In case of failure, the reader is set to an error state.
    ///
    /// # Returns
    ///
    /// the number of elements, or -1.
    #[doc(alias = "json_reader_count_elements")]
    fn count_elements(&self) -> i32 {
        unsafe {
            ffi::json_reader_count_elements(self.as_ref().to_glib_none().0)
        }
    }

    /// Counts the members of the current position, if the reader is
    /// positioned on an object.
    ///
    /// In case of failure, the reader is set to an error state.
    ///
    /// # Returns
    ///
    /// the number of members, or -1
    #[doc(alias = "json_reader_count_members")]
    fn count_members(&self) -> i32 {
        unsafe {
            ffi::json_reader_count_members(self.as_ref().to_glib_none().0)
        }
    }

    /// Moves the cursor back to the previous node after being positioned
    /// inside an array.
    ///
    /// This function resets the error state of the reader, if any was set.
    #[doc(alias = "json_reader_end_element")]
    fn end_element(&self) {
        unsafe {
            ffi::json_reader_end_element(self.as_ref().to_glib_none().0);
        }
    }

    /// Moves the cursor back to the previous node after being positioned
    /// inside an object.
    ///
    /// This function resets the error state of the reader, if any was set.
    #[doc(alias = "json_reader_end_member")]
    fn end_member(&self) {
        unsafe {
            ffi::json_reader_end_member(self.as_ref().to_glib_none().0);
        }
    }

    /// Retrieves the boolean value of the current position of the reader.
    ///
    /// See also: [`value()`][Self::value()]
    ///
    /// # Returns
    ///
    /// the boolean value
    #[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))
        }
    }

    /// Retrieves the reader node at the current position.
    ///
    /// # Returns
    ///
    /// the current node of the reader
    #[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))
        }
    }

    /// Retrieves the floating point value of the current position of the reader.
    ///
    /// See also: [`value()`][Self::value()]
    ///
    /// # Returns
    ///
    /// the floating point value
    #[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)
        }
    }

    /// Retrieves the error currently set on the reader.
    ///
    /// # Returns
    ///
    /// the current error
    #[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))
        }
    }

    /// Retrieves the integer value of the current position of the reader.
    ///
    /// See also: [`value()`][Self::value()]
    ///
    /// # Returns
    ///
    /// the integer value
    #[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)
        }
    }

    /// Retrieves the name of the current member.
    ///
    /// In case of failure, the reader is set to an error state.
    ///
    /// # Returns
    ///
    /// the name of the member
    #[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))
        }
    }

    /// Checks whether the value of the current position of the reader is `null`.
    ///
    /// See also: [`value()`][Self::value()]
    ///
    /// # Returns
    ///
    /// `TRUE` if `null` is set, and `FALSE` otherwise
    #[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))
        }
    }

    /// Retrieves the string value of the current position of the reader.
    ///
    /// See also: [`value()`][Self::value()]
    ///
    /// # Returns
    ///
    /// the string value
    #[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))
        }
    }

    /// Retrieves the value node at the current position of the reader.
    ///
    /// If the current position does not contain a scalar value, the reader
    /// is set to an error state.
    ///
    /// # Returns
    ///
    /// the current value node
    #[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))
        }
    }

    /// Checks whether the reader is currently on an array.
    ///
    /// # Returns
    ///
    /// `TRUE` if the reader is on an array
    #[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))
        }
    }

    /// Checks whether the reader is currently on an object.
    ///
    /// # Returns
    ///
    /// `TRUE` if the reader is on an object
    #[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))
        }
    }

    /// Checks whether the reader is currently on a value.
    ///
    /// # Returns
    ///
    /// `TRUE` if the reader is on a value
    #[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))
        }
    }

    /// Retrieves a list of member names from the current position, if the reader
    /// is positioned on an object.
    ///
    /// In case of failure, the reader is set to an error state.
    ///
    /// # Returns
    ///
    /// the members of
    ///   the object
    #[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))
        }
    }

    /// Advances the cursor of the reader to the element of the array or
    /// the member of the object at the given position.
    ///
    /// You can use [`value()`][Self::value()] and its wrapper functions to
    /// retrieve the value of the element; for instance, the following code will
    /// read the first element of the array at the current cursor position:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// json_reader_read_element (reader, 0);
    /// int_value = json_reader_get_int_value (reader);
    /// ```
    ///
    /// After reading the value, you should call [`end_element()`][Self::end_element()]
    /// to reposition the cursor inside the reader, e.g.:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// const char *str_value = NULL;
    ///
    /// json_reader_read_element (reader, 1);
    /// str_value = json_reader_get_string_value (reader);
    /// json_reader_end_element (reader);
    ///
    /// json_reader_read_element (reader, 2);
    /// str_value = json_reader_get_string_value (reader);
    /// json_reader_end_element (reader);
    /// ```
    ///
    /// If the reader is not currently on an array or an object, or if the index is
    /// bigger than the size of the array or the object, the reader will be
    /// put in an error state until [`end_element()`][Self::end_element()] is called. This
    /// means that, if used conditionally, [`end_element()`][Self::end_element()] must be
    /// called on all branches:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// if (!json_reader_read_element (reader, 1))
    ///   {
    ///     g_propagate_error (error, json_reader_get_error (reader));
    ///     json_reader_end_element (reader);
    ///     return FALSE;
    ///   }
    /// else
    ///   {
    ///     const char *str_value = json_reader_get_string_value (reader);
    ///     json_reader_end_element (reader);
    ///
    ///     // use str_value
    ///
    ///     return TRUE;
    ///   }
    /// ```c
    /// ## `index_`
    /// the index of the element
    ///
    /// # Returns
    ///
    /// `TRUE` on success, and `FALSE` otherwise
    #[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_))
        }
    }

    /// Advances the cursor of the reader to the `member_name` of the object at
    /// the current position.
    ///
    /// You can use [`value()`][Self::value()] and its wrapper functions to
    /// retrieve the value of the member; for instance:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// json_reader_read_member (reader, "width");
    /// width = json_reader_get_int_value (reader);
    /// ```
    ///
    /// After reading the value, `json_reader_end_member()` should be called to
    /// reposition the cursor inside the reader, e.g.:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// json_reader_read_member (reader, "author");
    /// author = json_reader_get_string_value (reader);
    /// json_reader_end_member (reader);
    ///
    /// json_reader_read_member (reader, "title");
    /// title = json_reader_get_string_value (reader);
    /// json_reader_end_member (reader);
    /// ```
    ///
    /// If the reader is not currently on an object, or if the `member_name` is not
    /// defined in the object, the reader will be put in an error state until
    /// [`end_member()`][Self::end_member()] is called. This means that if used
    /// conditionally, [`end_member()`][Self::end_member()] must be called on all branches:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// if (!json_reader_read_member (reader, "title"))
    ///   {
    ///     g_propagate_error (error, json_reader_get_error (reader));
    ///     json_reader_end_member (reader);
    ///     return FALSE;
    ///   }
    /// else
    ///   {
    ///     const char *str_value = json_reader_get_string_value (reader);
    ///     json_reader_end_member (reader);
    ///
    ///     // use str_value
    ///
    ///     return TRUE;
    ///   }
    /// ```
    /// ## `member_name`
    /// the name of the member to read
    ///
    /// # Returns
    ///
    /// `TRUE` on success, and `FALSE` otherwise
    #[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))
        }
    }

    /// Sets the root node of the JSON tree to be read by @self.
    ///
    /// The reader will take a copy of the node.
    /// ## `root`
    /// the root node
    #[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);
        }
    }

    /// The root of the JSON tree that the reader should read.
    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 {}