json-glib 0.1.1

// 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::*,translate::*};

glib::wrapper! {
    /// `JsonBuilder` provides an object for generating a JSON tree.
    ///
    /// The root of the JSON tree can be either a [`Object`][crate::Object] or a [`Array`][crate::Array].
    /// Thus the first call must necessarily be either
    /// [`BuilderExt::begin_object()`][crate::prelude::BuilderExt::begin_object()] or [`BuilderExt::begin_array()`][crate::prelude::BuilderExt::begin_array()].
    ///
    /// For convenience to language bindings, most `JsonBuilder` method return the
    /// instance, making it easy to chain function calls.
    ///
    /// ## Using `JsonBuilder`
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// g_autoptr(JsonBuilder) builder = json_builder_new ();
    ///
    /// json_builder_begin_object (builder);
    ///
    /// json_builder_set_member_name (builder, "url");
    /// json_builder_add_string_value (builder, "http://www.gnome.org/img/flash/two-thirty.png");
    ///
    /// json_builder_set_member_name (builder, "size");
    /// json_builder_begin_array (builder);
    /// json_builder_add_int_value (builder, 652);
    /// json_builder_add_int_value (builder, 242);
    /// json_builder_end_array (builder);
    ///
    /// json_builder_end_object (builder);
    ///
    /// g_autoptr(JsonNode) root = json_builder_get_root (builder);
    ///
    /// g_autoptr(JsonGenerator) gen = json_generator_new ();
    /// json_generator_set_root (gen, root);
    /// g_autofree char *str = json_generator_to_data (gen, NULL);
    ///
    /// // str now contains the following JSON data
    /// // { "url" : "http://www.gnome.org/img/flash/two-thirty.png", "size" : [ 652, 242 ] }
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `immutable`
    ///  Whether the tree should be immutable when created.
    ///
    /// Making the output immutable on creation avoids the expense
    /// of traversing it to make it immutable later.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`BuilderExt`][trait@crate::prelude::BuilderExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "JsonBuilder")]
    pub struct Builder(Object<ffi::JsonBuilder, ffi::JsonBuilderClass>);

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

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

    /// Creates a new `JsonBuilder`.
    ///
    /// You can use this object to generate a JSON tree and obtain the root node.
    ///
    /// # Returns
    ///
    /// the newly created builder instance
    #[doc(alias = "json_builder_new")]
    pub fn new() -> Builder {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::json_builder_new())
        }
    }

    /// Creates a new, immutable `JsonBuilder` instance.
    ///
    /// It is equivalent to setting the [`immutable`][struct@crate::Builder#immutable] property
    /// set to `TRUE` at construction time.
    ///
    /// # Returns
    ///
    /// the newly create builder instance
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "json_builder_new_immutable")]
    pub fn new_immutable() -> Builder {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::json_builder_new_immutable())
        }
    }

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

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

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

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

                            /// Whether the tree should be immutable when created.
                            ///
                            /// Making the output immutable on creation avoids the expense
                            /// of traversing it to make it immutable later.
                            #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn immutable(self, immutable: bool) -> Self {
                            Self { builder: self.builder.property("immutable", immutable), }
                        }

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

/// Trait containing all [`struct@Builder`] methods.
///
/// # Implementors
///
/// [`Builder`][struct@crate::Builder]
pub trait BuilderExt: IsA<Builder> + 'static {
    /// Adds a boolean value to the currently open object member or array.
    ///
    /// If called after [`set_member_name()`][Self::set_member_name()], sets the given value
    /// as the value of the current member in the open object; otherwise, the value
    /// is appended to the elements of the open array.
    ///
    /// See also: [`add_value()`][Self::add_value()]
    /// ## `value`
    /// the value of the member or element
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_add_boolean_value")]
#[must_use]
    fn add_boolean_value(&self, value: bool) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_add_boolean_value(self.as_ref().to_glib_none().0, value.into_glib()))
        }
    }

    /// Adds a floating point value to the currently open object member or array.
    ///
    /// If called after [`set_member_name()`][Self::set_member_name()], sets the given value
    /// as the value of the current member in the open object; otherwise, the value
    /// is appended to the elements of the open array.
    ///
    /// See also: [`add_value()`][Self::add_value()]
    /// ## `value`
    /// the value of the member or element
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_add_double_value")]
#[must_use]
    fn add_double_value(&self, value: f64) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_add_double_value(self.as_ref().to_glib_none().0, value))
        }
    }

    /// Adds an integer value to the currently open object member or array.
    ///
    /// If called after [`set_member_name()`][Self::set_member_name()], sets the given value
    /// as the value of the current member in the open object; otherwise, the value
    /// is appended to the elements of the open array.
    ///
    /// See also: [`add_value()`][Self::add_value()]
    /// ## `value`
    /// the value of the member or element
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_add_int_value")]
#[must_use]
    fn add_int_value(&self, value: i64) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_add_int_value(self.as_ref().to_glib_none().0, value))
        }
    }

    /// Adds a null value to the currently open object member or array.
    ///
    /// If called after [`set_member_name()`][Self::set_member_name()], sets the given value
    /// as the value of the current member in the open object; otherwise, the value
    /// is appended to the elements of the open array.
    ///
    /// See also: [`add_value()`][Self::add_value()]
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_add_null_value")]
#[must_use]
    fn add_null_value(&self) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_add_null_value(self.as_ref().to_glib_none().0))
        }
    }

    /// Adds a string value to the currently open object member or array.
    ///
    /// If called after [`set_member_name()`][Self::set_member_name()], sets the given value
    /// as the value of the current member in the open object; otherwise, the value
    /// is appended to the elements of the open array.
    ///
    /// See also: [`add_value()`][Self::add_value()]
    /// ## `value`
    /// the value of the member or element
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_add_string_value")]
#[must_use]
    fn add_string_value(&self, value: &str) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_add_string_value(self.as_ref().to_glib_none().0, value.to_glib_none().0))
        }
    }

    /// Adds a value to the currently open object member or array.
    ///
    /// If called after [`set_member_name()`][Self::set_member_name()], sets the given node
    /// as the value of the current member in the open object; otherwise, the node
    /// is appended to the elements of the open array.
    ///
    /// The builder will take ownership of the node.
    /// ## `node`
    /// the value of the member or element
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_add_value")]
#[must_use]
    fn add_value(&self, node: Node) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_add_value(self.as_ref().to_glib_none().0, node.into_glib_ptr()))
        }
    }

    /// Opens an array inside the given builder.
    ///
    /// You can add a new element to the array by using [`add_value()`][Self::add_value()].
    ///
    /// Once you added all elements to the array, you must call
    /// [`end_array()`][Self::end_array()] to close the array.
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_begin_array")]
#[must_use]
    fn begin_array(&self) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_begin_array(self.as_ref().to_glib_none().0))
        }
    }

    /// Opens an object inside the given builder.
    ///
    /// You can add a new member to the object by using [`set_member_name()`][Self::set_member_name()],
    /// followed by [`add_value()`][Self::add_value()].
    ///
    /// Once you added all members to the object, you must call [`end_object()`][Self::end_object()]
    /// to close the object.
    ///
    /// If the builder is in an inconsistent state, this function will return `NULL`.
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_begin_object")]
#[must_use]
    fn begin_object(&self) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_begin_object(self.as_ref().to_glib_none().0))
        }
    }

    /// Closes the array inside the given builder that was opened by the most
    /// recent call to [`begin_array()`][Self::begin_array()].
    ///
    /// This function cannot be called after [`set_member_name()`][Self::set_member_name()].
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_end_array")]
#[must_use]
    fn end_array(&self) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_end_array(self.as_ref().to_glib_none().0))
        }
    }

    /// Closes the object inside the given builder that was opened by the most
    /// recent call to [`begin_object()`][Self::begin_object()].
    ///
    /// This function cannot be called after [`set_member_name()`][Self::set_member_name()].
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_end_object")]
#[must_use]
    fn end_object(&self) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_end_object(self.as_ref().to_glib_none().0))
        }
    }

    /// Returns the root of the currently constructed tree.
    ///
    /// if the build is incomplete (ie: if there are any opened objects, or any
    /// open object members and array elements) then this function will return
    /// `NULL`.
    ///
    /// # Returns
    ///
    /// the root node
    #[doc(alias = "json_builder_get_root")]
    #[doc(alias = "get_root")]
    fn root(&self) -> Option<Node> {
        unsafe {
            from_glib_full(ffi::json_builder_get_root(self.as_ref().to_glib_none().0))
        }
    }

    /// Resets the state of the builder back to its initial state.
    #[doc(alias = "json_builder_reset")]
    fn reset(&self) {
        unsafe {
            ffi::json_builder_reset(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets the name of the member in an object.
    ///
    /// This function must be followed by of these functions:
    ///
    ///  - [`add_value()`][Self::add_value()], to add a scalar value to the member
    ///  - [`begin_object()`][Self::begin_object()], to add an object to the member
    ///  - [`begin_array()`][Self::begin_array()], to add an array to the member
    ///
    /// This function can only be called within an open object.
    /// ## `member_name`
    /// the name of the member
    ///
    /// # Returns
    ///
    /// the builder instance
    #[doc(alias = "json_builder_set_member_name")]
#[must_use]
    fn set_member_name(&self, member_name: &str) -> Option<Builder> {
        unsafe {
            from_glib_none(ffi::json_builder_set_member_name(self.as_ref().to_glib_none().0, member_name.to_glib_none().0))
        }
    }

    /// Whether the tree should be immutable when created.
    ///
    /// Making the output immutable on creation avoids the expense
    /// of traversing it to make it immutable later.
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    fn is_immutable(&self) -> bool {
        ObjectExt::property(self.as_ref(), "immutable")
    }
}

impl<O: IsA<Builder>> BuilderExt for O {}