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

use DigestAlgo;
use PubKeyAlgo;
use Trust;
use Validity;
use ffi;
use glib::object::IsA;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use libc;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// An object containing useful information about a certificate.
    ///
    /// # Implements
    ///
    /// [`CertificateExt`](trait.CertificateExt.html)
    pub struct Certificate(Object<ffi::GMimeCertificate, ffi::GMimeCertificateClass>);

    match fn {
        get_type => || ffi::g_mime_certificate_get_type(),
    }
}

impl Certificate {
    /// Creates a new `Certificate` object.
    ///
    /// # Returns
    ///
    /// a new `Certificate` object.
    pub fn new() -> Certificate {
        unsafe {
            from_glib_full(ffi::g_mime_certificate_new())
        }
    }
}

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

/// Trait containing all `Certificate` methods.
///
/// # Implementors
///
/// [`Certificate`](struct.Certificate.html)
pub trait CertificateExt {
    /// Get the creation date of the certificate's key.
    ///
    /// # Returns
    ///
    /// the creation date of the certificate's key or %-1 if unknown.
    fn get_created(&self) -> libc::c_long;

    /// Get the digest algorithm used by the certificate.
    ///
    /// # Returns
    ///
    /// the digest algorithm used by the certificate or
    /// `DigestAlgo::Default` if unspecified.
    fn get_digest_algo(&self) -> DigestAlgo;

    /// Get the email address associated with the certificate. If the
    /// certificate contains more than one email address with different
    /// validities, the email address with the highest validity is
    /// returned. If more than one email address appears in the
    /// certificate with the same (highest) validity, the first such email
    /// address will be returned.
    ///
    /// # Returns
    ///
    /// the relevant e-mail address, or `None` if unspecified.
    fn get_email(&self) -> Option<String>;

    /// Get the expiration date of the certificate's key.
    ///
    /// # Returns
    ///
    /// the expiration date of the certificate's key or %-1 if unknown.
    fn get_expires(&self) -> libc::c_long;

    /// Get the certificate's key fingerprint.
    ///
    /// # Returns
    ///
    /// the certificate's key fingerprint or `None` if unspecified.
    fn get_fingerprint(&self) -> Option<String>;

    /// Get the validity of the certificate's identity information. This
    /// validity applies to the name, email, and user_id fields associated
    /// with the certificate.
    ///
    /// # Returns
    ///
    /// the identity validity of the certificate.
    fn get_id_validity(&self) -> Validity;

    /// Get the certificate's issuer name.
    ///
    /// # Returns
    ///
    /// the certificate's issuer name or `None` if unspecified.
    fn get_issuer_name(&self) -> Option<String>;

    /// Get the certificate's issuer serial.
    ///
    /// # Returns
    ///
    /// the certificate's issuer serial or `None` if unspecified.
    fn get_issuer_serial(&self) -> Option<String>;

    /// Get the certificate's key id.
    ///
    /// # Returns
    ///
    /// the certificate's key id or `None` if unspecified.
    fn get_key_id(&self) -> Option<String>;

    /// Get the name associated with the certificate. For email
    /// certificates, this is usually the name of the person who controls
    /// the certificate (encoded in UTF-8). If the certificate contains
    /// more than one name with different validities, the name with the
    /// highest validity is returned. If more than one name appears in the
    /// certificate with the same (highest) validity, the first such name
    /// will be returned.
    ///
    /// # Returns
    ///
    /// the the relevant name or `None` if unspecified.
    fn get_name(&self) -> Option<String>;

    /// Get the public-key algorithm used by the certificate.
    ///
    /// # Returns
    ///
    /// the public-key algorithm used by the certificate or
    /// `PubKeyAlgo::Default` if unspecified.
    fn get_pubkey_algo(&self) -> PubKeyAlgo;

    /// Get the certificate trust.
    ///
    /// # Returns
    ///
    /// the certificate trust.
    fn get_trust(&self) -> Trust;

    /// Get the certificate's full User ID. If the certificate contains
    /// more than one User ID with different validities, the User ID with
    /// the highest validity is returned. If more than one User ID appears
    /// in the certificate with the same (highest) validity, the first such
    /// User ID will be returned.
    ///
    /// # Returns
    ///
    /// the relevant User ID or `None` if unspecified.
    fn get_user_id(&self) -> Option<String>;

    /// Set the creation date of the certificate's key.
    /// ## `created`
    /// creation date
    fn set_created(&self, created: libc::c_long);

    /// Set the digest algorithm used by the certificate.
    /// ## `algo`
    /// a `DigestAlgo`
    fn set_digest_algo(&self, algo: DigestAlgo);

    /// Set the email address associated with the
    /// certificate. (e.g. "jane\@example.org")
    /// ## `email`
    /// certificate's email
    fn set_email(&self, email: &str);

    /// Set the expiration date of the certificate's key.
    /// ## `expires`
    /// expiration date
    fn set_expires(&self, expires: libc::c_long);

    /// Set the certificate's key fingerprint.
    /// ## `fingerprint`
    /// fingerprint string
    fn set_fingerprint(&self, fingerprint: &str);

    /// Set the validity associated with the certificate's name, email, and user_id.
    /// ## `validity`
    /// a `Validity` representing the validity of the certificate's identity information.
    fn set_id_validity(&self, validity: Validity);

    /// Set the certificate's issuer name.
    /// ## `issuer_name`
    /// certificate's issuer name
    fn set_issuer_name(&self, issuer_name: &str);

    /// Set the certificate's issuer serial.
    /// ## `issuer_serial`
    /// certificate's issuer serial
    fn set_issuer_serial(&self, issuer_serial: &str);

    /// Set the certificate's key id.
    /// ## `key_id`
    /// key id
    fn set_key_id(&self, key_id: &str);

    /// Set the name associated with the certificate. For email
    /// certificates, this is usually the name of the person who controls
    /// the certificate (encoded in UTF-8). (e.g. "Jane Doe")
    /// ## `name`
    /// certificate's name
    fn set_name(&self, name: &str);

    /// Set the public-key algorithm used by the certificate.
    /// ## `algo`
    /// a `PubKeyAlgo`
    fn set_pubkey_algo(&self, algo: PubKeyAlgo);

    /// Set the certificate trust.
    /// ## `trust`
    /// a `Trust` value
    fn set_trust(&self, trust: Trust);

    /// Set the certificate's full User ID. By convention, this is usually
    /// a mail name-addr as described in RFC 5322. (e.g. "Jane Doe
    /// &lt;jane\@example.org&gt;")
    /// ## `user_id`
    /// the full User ID for a certificate
    fn set_user_id(&self, user_id: &str);
}

impl<O: IsA<Certificate>> CertificateExt for O {
    fn get_created(&self) -> libc::c_long {
        unsafe {
            ffi::g_mime_certificate_get_created(self.to_glib_none().0)
        }
    }

    fn get_digest_algo(&self) -> DigestAlgo {
        unsafe {
            from_glib(ffi::g_mime_certificate_get_digest_algo(self.to_glib_none().0))
        }
    }

    fn get_email(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_email(self.to_glib_none().0))
        }
    }

    fn get_expires(&self) -> libc::c_long {
        unsafe {
            ffi::g_mime_certificate_get_expires(self.to_glib_none().0)
        }
    }

    fn get_fingerprint(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_fingerprint(self.to_glib_none().0))
        }
    }

    fn get_id_validity(&self) -> Validity {
        unsafe {
            from_glib(ffi::g_mime_certificate_get_id_validity(self.to_glib_none().0))
        }
    }

    fn get_issuer_name(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_issuer_name(self.to_glib_none().0))
        }
    }

    fn get_issuer_serial(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_issuer_serial(self.to_glib_none().0))
        }
    }

    fn get_key_id(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_key_id(self.to_glib_none().0))
        }
    }

    fn get_name(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_name(self.to_glib_none().0))
        }
    }

    fn get_pubkey_algo(&self) -> PubKeyAlgo {
        unsafe {
            from_glib(ffi::g_mime_certificate_get_pubkey_algo(self.to_glib_none().0))
        }
    }

    fn get_trust(&self) -> Trust {
        unsafe {
            from_glib(ffi::g_mime_certificate_get_trust(self.to_glib_none().0))
        }
    }

    fn get_user_id(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_certificate_get_user_id(self.to_glib_none().0))
        }
    }

    fn set_created(&self, created: libc::c_long) {
        unsafe {
            ffi::g_mime_certificate_set_created(self.to_glib_none().0, created);
        }
    }

    fn set_digest_algo(&self, algo: DigestAlgo) {
        unsafe {
            ffi::g_mime_certificate_set_digest_algo(self.to_glib_none().0, algo.to_glib());
        }
    }

    fn set_email(&self, email: &str) {
        unsafe {
            ffi::g_mime_certificate_set_email(self.to_glib_none().0, email.to_glib_none().0);
        }
    }

    fn set_expires(&self, expires: libc::c_long) {
        unsafe {
            ffi::g_mime_certificate_set_expires(self.to_glib_none().0, expires);
        }
    }

    fn set_fingerprint(&self, fingerprint: &str) {
        unsafe {
            ffi::g_mime_certificate_set_fingerprint(self.to_glib_none().0, fingerprint.to_glib_none().0);
        }
    }

    fn set_id_validity(&self, validity: Validity) {
        unsafe {
            ffi::g_mime_certificate_set_id_validity(self.to_glib_none().0, validity.to_glib());
        }
    }

    fn set_issuer_name(&self, issuer_name: &str) {
        unsafe {
            ffi::g_mime_certificate_set_issuer_name(self.to_glib_none().0, issuer_name.to_glib_none().0);
        }
    }

    fn set_issuer_serial(&self, issuer_serial: &str) {
        unsafe {
            ffi::g_mime_certificate_set_issuer_serial(self.to_glib_none().0, issuer_serial.to_glib_none().0);
        }
    }

    fn set_key_id(&self, key_id: &str) {
        unsafe {
            ffi::g_mime_certificate_set_key_id(self.to_glib_none().0, key_id.to_glib_none().0);
        }
    }

    fn set_name(&self, name: &str) {
        unsafe {
            ffi::g_mime_certificate_set_name(self.to_glib_none().0, name.to_glib_none().0);
        }
    }

    fn set_pubkey_algo(&self, algo: PubKeyAlgo) {
        unsafe {
            ffi::g_mime_certificate_set_pubkey_algo(self.to_glib_none().0, algo.to_glib());
        }
    }

    fn set_trust(&self, trust: Trust) {
        unsafe {
            ffi::g_mime_certificate_set_trust(self.to_glib_none().0, trust.to_glib());
        }
    }

    fn set_user_id(&self, user_id: &str) {
        unsafe {
            ffi::g_mime_certificate_set_user_id(self.to_glib_none().0, user_id.to_glib_none().0);
        }
    }
}