json_glib/auto/

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

glib::wrapper! {
    /// `JsonGenerator` provides an object for generating a JSON data stream
    /// from a tree of [`Node`][crate::Node] instances, and put it into a buffer
    /// or a file.
    ///
    /// ## Properties
    ///
    ///
    /// #### `indent`
    ///  Number of spaces to be used to indent when pretty printing.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `indent-char`
    ///  The character that should be used when indenting in pretty print.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pretty`
    ///  Whether the output should be "pretty-printed", with indentation and
    /// newlines.
    ///
    /// The indentation level can be controlled by using the
    /// [`indent`][struct@crate::Generator#indent] property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `root`
    ///  The root node to be used when constructing a JSON data
    /// stream.
    ///
    /// Readable | Writeable
    ///
    /// # Implements
    ///
    /// [`GeneratorExt`][trait@crate::prelude::GeneratorExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "JsonGenerator")]
    pub struct Generator(Object<ffi::JsonGenerator, ffi::JsonGeneratorClass>);

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

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

    /// Creates a new `JsonGenerator`.
    ///
    /// You can use this object to generate a JSON data stream starting from a
    /// data object model composed by [`Node`][crate::Node]s.
    ///
    /// # Returns
    ///
    /// the newly created generator instance
    #[doc(alias = "json_generator_new")]
    pub fn new() -> Generator {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::json_generator_new()) }
    }

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

impl Default for Generator {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Generator`] 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 GeneratorBuilder {
    builder: glib::object::ObjectBuilder<'static, Generator>,
}

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

    /// Number of spaces to be used to indent when pretty printing.
    pub fn indent(self, indent: u32) -> Self {
        Self {
            builder: self.builder.property("indent", indent),
        }
    }

    /// The character that should be used when indenting in pretty print.
    pub fn indent_char(self, indent_char: u32) -> Self {
        Self {
            builder: self.builder.property("indent-char", indent_char),
        }
    }

    /// Whether the output should be "pretty-printed", with indentation and
    /// newlines.
    ///
    /// The indentation level can be controlled by using the
    /// [`indent`][struct@crate::Generator#indent] property.
    pub fn pretty(self, pretty: bool) -> Self {
        Self {
            builder: self.builder.property("pretty", pretty),
        }
    }

    /// The root node to be used when constructing a JSON data
    /// stream.
    pub fn root(self, root: &Node) -> Self {
        Self {
            builder: self.builder.property("root", root.clone()),
        }
    }

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

/// Trait containing all [`struct@Generator`] methods.
///
/// # Implementors
///
/// [`Generator`][struct@crate::Generator]
pub trait GeneratorExt: IsA<Generator> + 'static {
    /// Retrieves the value set using [`set_indent()`][Self::set_indent()].
    ///
    /// # Returns
    ///
    /// the number of repetitions per indentation level
    #[doc(alias = "json_generator_get_indent")]
    #[doc(alias = "get_indent")]
    fn indent(&self) -> u32 {
        unsafe { ffi::json_generator_get_indent(self.as_ref().to_glib_none().0) }
    }

    /// Retrieves the value set using [`set_indent_char()`][Self::set_indent_char()].
    ///
    /// # Returns
    ///
    /// the character to be used when indenting
    #[doc(alias = "json_generator_get_indent_char")]
    #[doc(alias = "get_indent_char")]
    #[doc(alias = "indent-char")]
    fn indent_char(&self) -> char {
        unsafe {
            std::convert::TryFrom::try_from(ffi::json_generator_get_indent_char(
                self.as_ref().to_glib_none().0,
            ))
            .expect("conversion from an invalid Unicode value attempted")
        }
    }

    /// Retrieves the value set using [`set_pretty()`][Self::set_pretty()].
    ///
    /// # Returns
    ///
    /// `TRUE` if the generated JSON should be pretty-printed, and
    ///   `FALSE` otherwise
    #[doc(alias = "json_generator_get_pretty")]
    #[doc(alias = "get_pretty")]
    #[doc(alias = "pretty")]
    fn is_pretty(&self) -> bool {
        unsafe {
            from_glib(ffi::json_generator_get_pretty(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves a pointer to the root node set using
    /// [`set_root()`][Self::set_root()].
    ///
    /// # Returns
    ///
    /// the root node
    #[doc(alias = "json_generator_get_root")]
    #[doc(alias = "get_root")]
    fn root(&self) -> Option<Node> {
        unsafe { from_glib_none(ffi::json_generator_get_root(self.as_ref().to_glib_none().0)) }
    }

    /// Sets the number of repetitions for each indentation level.
    /// ## `indent_level`
    /// the number of repetitions of the indentation character
    ///   that should be applied when pretty printing
    #[doc(alias = "json_generator_set_indent")]
    #[doc(alias = "indent")]
    fn set_indent(&self, indent_level: u32) {
        unsafe {
            ffi::json_generator_set_indent(self.as_ref().to_glib_none().0, indent_level);
        }
    }

    /// Sets the character to be used when indenting.
    /// ## `indent_char`
    /// a Unicode character to be used when indenting
    #[doc(alias = "json_generator_set_indent_char")]
    #[doc(alias = "indent-char")]
    fn set_indent_char(&self, indent_char: char) {
        unsafe {
            ffi::json_generator_set_indent_char(
                self.as_ref().to_glib_none().0,
                indent_char.into_glib(),
            );
        }
    }

    /// Sets whether the generated JSON should be pretty printed.
    ///
    /// Pretty printing will use indentation character specified in the
    /// [`indent-char`][struct@crate::Generator#indent-char] property and the spacing
    /// specified in the [`indent`][struct@crate::Generator#indent] property.
    /// ## `is_pretty`
    /// whether the generated string should be pretty printed
    #[doc(alias = "json_generator_set_pretty")]
    #[doc(alias = "pretty")]
    fn set_pretty(&self, is_pretty: bool) {
        unsafe {
            ffi::json_generator_set_pretty(self.as_ref().to_glib_none().0, is_pretty.into_glib());
        }
    }

    /// Sets the root of the JSON data stream to be serialized by
    /// the given generator.
    ///
    /// The passed `node` is copied by the generator object, so it can be
    /// safely freed after calling this function.
    /// ## `node`
    /// the root node
    #[doc(alias = "json_generator_set_root")]
    #[doc(alias = "root")]
    fn set_root(&self, node: &Node) {
        unsafe {
            ffi::json_generator_set_root(self.as_ref().to_glib_none().0, node.to_glib_none().0);
        }
    }

    /// Sets the root of the JSON data stream to be serialized by
    /// the given generator.
    ///
    /// The ownership of the passed `node` is transferred to the generator object.
    /// ## `node`
    /// the root node
    #[cfg(feature = "v1_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
    #[doc(alias = "json_generator_take_root")]
    fn take_root(&self, node: Option<Node>) {
        unsafe {
            ffi::json_generator_take_root(self.as_ref().to_glib_none().0, node.into_glib_ptr());
        }
    }

    /// Generates a JSON data stream from @self and returns it as a
    /// buffer.
    ///
    /// # Returns
    ///
    /// a newly allocated string holding a JSON data stream
    ///
    /// ## `length`
    /// return location for the length of the returned
    ///   buffer
    #[doc(alias = "json_generator_to_data")]
    fn to_data(&self) -> (glib::GString, usize) {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = from_glib_full(ffi::json_generator_to_data(
                self.as_ref().to_glib_none().0,
                length.as_mut_ptr(),
            ));
            (ret, length.assume_init())
        }
    }

    /// Creates a JSON data stream and puts it inside `filename`, overwriting
    /// the file's current contents.
    ///
    /// This operation is atomic, in the sense that the data is written to a
    /// temporary file which is then renamed to the given `filename`.
    /// ## `filename`
    /// the path to the target file
    ///
    /// # Returns
    ///
    /// [`true`] if saving was successful.
    #[doc(alias = "json_generator_to_file")]
    fn to_file(&self, filename: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::json_generator_to_file(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    // TODO: Find a way around converting glib::ffi::GString to glib::GString
    // #[cfg(feature = "v1_4")]
    // #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    // #[doc(alias = "json_generator_to_gstring")]
    // fn to_gstring(&self, string: &mut String) -> glib::GString {
    //     unsafe {
    //         from_glib_none(ffi::json_generator_to_gstring(
    //             self.as_ref().to_glib_none().0,
    //             string.as_gstr().to_glib_none().0,
    //         ))
    //     }
    // }

    /// Outputs JSON data and writes it (synchronously) to the given stream.
    /// ## `stream`
    /// the output stream used to write the JSON data
    /// ## `cancellable`
    /// a `GCancellable`
    ///
    /// # Returns
    ///
    /// whether the write operation was successful
    #[doc(alias = "json_generator_to_stream")]
    fn to_stream(
        &self,
        stream: &impl IsA<gio::OutputStream>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::json_generator_to_stream(
                self.as_ref().to_glib_none().0,
                stream.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

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

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

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

    #[doc(alias = "root")]
    fn connect_root_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_root_trampoline<P: IsA<Generator>, F: Fn(&P) + 'static>(
            this: *mut ffi::JsonGenerator,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Generator::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<Generator>> GeneratorExt for O {}