use crate::{ffi, IssueSeverity, ValidatorIssue};
use glib::{prelude::*, translate::*};
glib::wrapper! {
#[doc(alias = "AsValidator")]
pub struct Validator(Object<ffi::AsValidator, ffi::AsValidatorClass>);
match fn {
type_ => || ffi::as_validator_get_type(),
}
}
impl Validator {
pub const NONE: Option<&'static Validator> = None;
#[doc(alias = "as_validator_new")]
pub fn new() -> Validator {
assert_initialized_main_thread!();
unsafe { from_glib_full(ffi::as_validator_new()) }
}
}
impl Default for Validator {
fn default() -> Self {
Self::new()
}
}
pub trait ValidatorExt: IsA<Validator> + 'static {
#[doc(alias = "as_validator_add_override")]
fn add_override(&self, tag: &str, severity_override: IssueSeverity) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::as_validator_add_override(
self.as_ref().to_glib_none().0,
tag.to_glib_none().0,
severity_override.into_glib(),
&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 = "as_validator_add_release_bytes")]
fn add_release_bytes(
&self,
release_fname: &str,
release_metadata: &glib::Bytes,
) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::as_validator_add_release_bytes(
self.as_ref().to_glib_none().0,
release_fname.to_glib_none().0,
release_metadata.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 = "as_validator_add_release_file")]
fn add_release_file(&self, release_file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::as_validator_add_release_file(
self.as_ref().to_glib_none().0,
release_file.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 = "as_validator_check_success")]
fn check_success(&self) -> bool {
unsafe {
from_glib(ffi::as_validator_check_success(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_clear_release_data")]
fn clear_release_data(&self) {
unsafe {
ffi::as_validator_clear_release_data(self.as_ref().to_glib_none().0);
}
}
#[doc(alias = "as_validator_get_allow_net")]
#[doc(alias = "get_allow_net")]
fn allows_net(&self) -> bool {
unsafe {
from_glib(ffi::as_validator_get_allow_net(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_get_issue_files_count")]
#[doc(alias = "get_issue_files_count")]
fn issue_files_count(&self) -> u32 {
unsafe { ffi::as_validator_get_issue_files_count(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "as_validator_get_issues")]
#[doc(alias = "get_issues")]
fn issues(&self) -> Vec<ValidatorIssue> {
unsafe {
FromGlibPtrContainer::from_glib_container(ffi::as_validator_get_issues(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_get_report_yaml")]
#[doc(alias = "get_report_yaml")]
fn report_yaml(&self) -> Result<glib::GString, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::as_validator_get_report_yaml(self.as_ref().to_glib_none().0, &mut error);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "as_validator_get_strict")]
#[doc(alias = "get_strict")]
fn is_strict(&self) -> bool {
unsafe { from_glib(ffi::as_validator_get_strict(self.as_ref().to_glib_none().0)) }
}
#[doc(alias = "as_validator_get_tag_explanation")]
#[doc(alias = "get_tag_explanation")]
fn tag_explanation(&self, tag: &str) -> Option<glib::GString> {
unsafe {
from_glib_none(ffi::as_validator_get_tag_explanation(
self.as_ref().to_glib_none().0,
tag.to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_get_tag_severity")]
#[doc(alias = "get_tag_severity")]
fn tag_severity(&self, tag: &str) -> IssueSeverity {
unsafe {
from_glib(ffi::as_validator_get_tag_severity(
self.as_ref().to_glib_none().0,
tag.to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_get_tags")]
#[doc(alias = "get_tags")]
fn tags(&self) -> Vec<glib::GString> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::as_validator_get_tags(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_set_allow_net")]
fn set_allow_net(&self, value: bool) {
unsafe {
ffi::as_validator_set_allow_net(self.as_ref().to_glib_none().0, value.into_glib());
}
}
#[doc(alias = "as_validator_set_strict")]
fn set_strict(&self, is_strict: bool) {
unsafe {
ffi::as_validator_set_strict(self.as_ref().to_glib_none().0, is_strict.into_glib());
}
}
#[doc(alias = "as_validator_validate_bytes")]
fn validate_bytes(&self, metadata: &glib::Bytes) -> bool {
unsafe {
from_glib(ffi::as_validator_validate_bytes(
self.as_ref().to_glib_none().0,
metadata.to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_validate_data")]
fn validate_data(&self, metadata: &str) -> bool {
unsafe {
from_glib(ffi::as_validator_validate_data(
self.as_ref().to_glib_none().0,
metadata.to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_validate_file")]
fn validate_file(&self, metadata_file: &impl IsA<gio::File>) -> bool {
unsafe {
from_glib(ffi::as_validator_validate_file(
self.as_ref().to_glib_none().0,
metadata_file.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "as_validator_validate_tree")]
fn validate_tree(&self, root_dir: &str) -> bool {
unsafe {
from_glib(ffi::as_validator_validate_tree(
self.as_ref().to_glib_none().0,
root_dir.to_glib_none().0,
))
}
}
}
impl<O: IsA<Validator>> ValidatorExt for O {}