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

use crate::ffi;
use glib::translate::*;

glib::wrapper! {
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Regex(Shared<ffi::VteRegex>);

    match fn {
        ref => |ptr| ffi::vte_regex_ref(ptr),
        unref => |ptr| ffi::vte_regex_unref(ptr),
        type_ => || ffi::vte_regex_get_type(),
    }
}

impl Regex {
    /// Compiles @pattern into a regex for use as a match regex
    /// with vte_terminal_match_add_regex() or
    /// vte_terminal_event_check_regex_simple().
    ///
    /// See man:pcre2pattern(3) for information
    /// about the supported regex language, and man:pcre2api(3) for
    /// information about the supported @flags.
    ///
    /// The regex will be compiled using <literal>PCRE2_UTF</literal> and
    /// possibly other flags, in addition to the flags supplied in @flags.
    /// ## `pattern`
    /// a regex pattern string
    /// ## `pattern_length`
    /// the length of @pattern in bytes, or -1 if the
    ///  string is NUL-terminated and the length is unknown
    /// ## `flags`
    /// PCRE2 compile flags
    ///
    /// # Returns
    ///
    /// a newly created #VteRegex, or [`None`] with @error filled in
    #[doc(alias = "vte_regex_new_for_match")]
    #[doc(alias = "new_for_match")]
    pub fn for_match(pattern: &str, flags: u32) -> Result<Regex, glib::Error> {
        assert_initialized_main_thread!();
        let pattern_length = pattern.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::vte_regex_new_for_match(
                pattern.to_glib_none().0,
                pattern_length,
                flags,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Compiles @pattern into a regex for use as a match regex
    /// with vte_terminal_match_add_regex() or
    /// vte_terminal_event_check_regex_simple().
    ///
    /// See man:pcre2pattern(3) for information
    /// about the supported regex language, and man:pcre2api(3) for
    /// information about the supported @flags and @extra_flags.
    ///
    /// The regex will be compiled using <literal>PCRE2_UTF</literal> and
    /// possibly other flags, in addition to the flags supplied in @flags.
    ///
    /// If regex compilation fails, @error will be set and @error_offset point
    /// to error as an offset into @pattern.
    /// ## `pattern`
    /// a regex pattern string
    /// ## `pattern_length`
    /// the length of @pattern in bytes, or -1 if the
    ///  string is NUL-terminated and the length is unknown
    /// ## `flags`
    /// PCRE2 compile flags
    /// ## `extra_flags`
    /// PCRE2 extra compile flags
    ///
    /// # Returns
    ///
    /// a newly created #VteRegex, or [`None`]
    ///
    /// ## `error_offset`
    /// return location to store the error offset
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_regex_new_for_match_full")]
    #[doc(alias = "new_for_match_full")]
    pub fn for_match_full(
        pattern: &str,
        flags: u32,
        extra_flags: u32,
    ) -> Result<(Regex, usize), glib::Error> {
        assert_initialized_main_thread!();
        let pattern_length = pattern.len() as _;
        unsafe {
            let mut error_offset = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let ret = ffi::vte_regex_new_for_match_full(
                pattern.to_glib_none().0,
                pattern_length,
                flags,
                extra_flags,
                error_offset.as_mut_ptr(),
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), error_offset.assume_init()))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Compiles @pattern into a regex for use as a search regex
    /// with vte_terminal_search_set_regex().
    ///
    /// See man:pcre2pattern(3) for information
    /// about the supported regex language, and man:pcre2api(3) for
    /// information about the supported @flags.
    ///
    /// The regex will be compiled using <literal>PCRE2_UTF</literal> and
    /// possibly other flags, in addition to the flags supplied in @flags.
    /// ## `pattern`
    /// a regex pattern string
    /// ## `pattern_length`
    /// the length of @pattern in bytes, or -1 if the
    ///  string is NUL-terminated and the length is unknown
    /// ## `flags`
    /// PCRE2 compile flags
    ///
    /// # Returns
    ///
    /// a newly created #VteRegex, or [`None`] with @error filled in
    #[doc(alias = "vte_regex_new_for_search")]
    #[doc(alias = "new_for_search")]
    pub fn for_search(pattern: &str, flags: u32) -> Result<Regex, glib::Error> {
        assert_initialized_main_thread!();
        let pattern_length = pattern.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::vte_regex_new_for_search(
                pattern.to_glib_none().0,
                pattern_length,
                flags,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Compiles @pattern into a regex for use as a search regex
    /// with vte_terminal_search_set_regex().
    ///
    /// See man:pcre2pattern(3) for information
    /// about the supported regex language, and man:pcre2api(3) for
    /// information about the supported @flags and @extra_flags.
    ///
    /// The regex will be compiled using <literal>PCRE2_UTF</literal> and
    /// possibly other flags, in addition to the flags supplied in @flags.
    ///
    /// If regex compilation fails, @error will be set and @error_offset point
    /// to error as an offset into @pattern.
    /// ## `pattern`
    /// a regex pattern string
    /// ## `pattern_length`
    /// the length of @pattern in bytes, or -1 if the
    ///  string is NUL-terminated and the length is unknown
    /// ## `flags`
    /// PCRE2 compile flags
    ///
    /// # Returns
    ///
    /// a newly created #VteRegex, or [`None`]
    ///
    /// ## `error_offset`
    /// return location to store the error offset
    #[cfg(feature = "v0_76")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v0_76")))]
    #[doc(alias = "vte_regex_new_for_search_full")]
    #[doc(alias = "new_for_search_full")]
    pub fn for_search_full(
        pattern: &str,
        flags: u32,
        extra_flags: u32,
    ) -> Result<(Regex, usize), glib::Error> {
        assert_initialized_main_thread!();
        let pattern_length = pattern.len() as _;
        unsafe {
            let mut error_offset = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let ret = ffi::vte_regex_new_for_search_full(
                pattern.to_glib_none().0,
                pattern_length,
                flags,
                extra_flags,
                error_offset.as_mut_ptr(),
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), error_offset.assume_init()))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// If the platform supports JITing, JIT compiles @self.
    /// ## `flags`
    /// PCRE2 JIT flags, or 0
    ///
    /// # Returns
    ///
    /// [`true`] if JITing succeeded (or PCRE2 was built without
    ///   JIT support), or [`false`] with @error filled in
    #[doc(alias = "vte_regex_jit")]
    pub fn jit(&self, flags: u32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::vte_regex_jit(self.to_glib_none().0, flags, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// See man:pcre2api(3) and man:pcre2_substitute(3) for more information.
    /// ## `subject`
    /// the subject string
    /// ## `replacement`
    /// the replacement string
    /// ## `flags`
    /// PCRE2 match flags
    ///
    /// # Returns
    ///
    /// the substituted string, or [`None`]
    ///   if an error occurred
    #[doc(alias = "vte_regex_substitute")]
    pub fn substitute(
        &self,
        subject: &str,
        replacement: &str,
        flags: u32,
    ) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::vte_regex_substitute(
                self.to_glib_none().0,
                subject.to_glib_none().0,
                replacement.to_glib_none().0,
                flags,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}