Add error domain example

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Author: elmarco

Makefile

@@ -1,5 +1,6 @@
 HEADERS = \
 	include/ex/ex.h \
+	include/ex/error.h \
 	include/ex/flags.h \
 	include/ex/color.h \
 	include/ex/foo.h \
@@ -13,6 +14,9 @@ RUST_SOURCES = \
 	src/color/ffi.rs \
 	src/color/imp.rs \
 	src/color/mod.rs \
+	src/error/ffi.rs \
+	src/error/imp.rs \
+	src/error/mod.rs \
 	src/flags/ffi.rs \
 	src/flags/imp.rs \
 	src/flags/mod.rs \

include/ex/error.h

@@ -0,0 +1,20 @@
+#ifndef __ERROR_H_
+#define __ERROR_H_
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef enum ExError
+{
+  EX_ERROR_INVALID_ARGUMENT,
+  EX_ERROR_FAILED,
+} ExError;
+
+#define EX_ERROR           (ex_error_quark())
+
+GQuark ex_error_quark      (void);
+
+G_END_DECLS
+
+#endif /* __ERROR_H_ */

include/ex/ex.h

@@ -1,6 +1,7 @@
 #ifndef __EX_H__
 #define __EX_H__
 
+#include "error.h"
 #include "flags.h"
 #include "color.h"
 #include "foo.h"

src/color/mod.rs

@@ -6,7 +6,7 @@ use imp::ffi;
 #[cfg(feature = "bindings")]
 mod ffi;
 
-use glib::{StaticType, Type, translate::*};
+use glib::{translate::*, StaticType, Type};
 
 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
 #[non_exhaustive]

src/error/ffi.rs

@@ -0,0 +1,10 @@
+use libc::c_int;
+
+pub type ExError = c_int;
+
+pub const EX_ERROR_INVALID_ARGUMENT: ExError = 0;
+pub const EX_ERROR_FAILED: ExError = 1;
+
+extern "C" {
+    pub fn ex_error_quark() -> glib::ffi::GQuark;
+}

src/error/imp.rs

@@ -0,0 +1,21 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, glib::GErrorDomain)]
+#[gerror_domain(name = "ExError")]
+#[repr(C)]
+pub enum Error {
+    InvalidArgument,
+    Failed,
+}
+
+pub(crate) mod ffi {
+    use glib::translate::*;
+
+    pub type ExError = i32;
+
+    pub const EX_ERROR_INVALID_ARGUMENT: ExError = super::Error::InvalidArgument as i32;
+    pub const EX_ERROR_FAILED: ExError = super::Error::Failed as i32;
+
+    #[no_mangle]
+    pub unsafe extern "C" fn ex_error_quark() -> glib::ffi::GQuark {
+        <super::Error as glib::error::ErrorDomain>::domain().into_glib()
+    }
+}

src/error/mod.rs

@@ -0,0 +1,65 @@
+#[cfg(not(feature = "bindings"))]
+pub mod imp;
+#[cfg(not(feature = "bindings"))]
+use imp::ffi;
+
+#[cfg(feature = "bindings")]
+mod ffi;
+
+use glib::translate::*;
+
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[non_exhaustive]
+pub enum Error {
+    InvalidArgument,
+    Failed,
+    __Unknown(i32),
+}
+
+impl IntoGlib for Error {
+    type GlibType = ffi::ExError;
+
+    fn into_glib(self) -> ffi::ExError {
+        match self {
+            Error::InvalidArgument => ffi::EX_ERROR_INVALID_ARGUMENT,
+            Error::Failed => ffi::EX_ERROR_FAILED,
+            Error::__Unknown(value) => value,
+        }
+    }
+}
+
+impl FromGlib<ffi::ExError> for Error {
+    unsafe fn from_glib(value: ffi::ExError) -> Self {
+        match value {
+            0 => Error::InvalidArgument,
+            1 => Error::Failed,
+            value => Error::__Unknown(value),
+        }
+    }
+}
+
+impl glib::error::ErrorDomain for Error {
+    fn domain() -> glib::Quark {
+        unsafe { from_glib(ffi::ex_error_quark()) }
+    }
+
+    fn code(self) -> i32 {
+        self.into_glib()
+    }
+
+    fn from(code: i32) -> Option<Self> {
+        unsafe { Some(Self::from_glib(code)) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_error() {
+        let err = glib::Error::new(Error::Failed, "We are all mad here.");
+        assert!(err.is::<Error>());
+        assert!(matches!(err.kind::<Error>(), Some(Error::Failed)));
+    }
+}

src/flags/mod.rs

@@ -6,7 +6,7 @@ use imp::ffi;
 #[cfg(feature = "bindings")]
 mod ffi;
 
-use glib::{StaticType, Type, translate::*};
+use glib::{translate::*, StaticType, Type};
 
 use bitflags::bitflags;
 
@@ -52,6 +52,5 @@ mod tests {
         let v = e.value(1).unwrap();
         assert_eq!(v.name(), "Some");
         assert_eq!(v.nick(), "some");
-
     }
 }

src/lib.rs

@@ -1,7 +1,8 @@
 pub mod bar;
+pub mod color;
+pub mod error;
+pub mod flags;
 pub mod foo;
 pub mod nameable;
 pub mod rstring;
 pub mod shared_rstring;
-pub mod color;
-pub mod flags;

test.vala

@@ -4,6 +4,10 @@ void on_incremented (int val, int inc) {
 	stdout.printf ("incremented to %d by %d\n", val, inc);
 }
 
+void throw_err() throws Ex.Error {
+	throw new Ex.Error.FAILED ("something went wrong");
+}
+
 public int main (string[] args) {
 	var foo = new Ex.Foo ("foo's name");
 	foo.incremented.connect (on_incremented);
@@ -41,5 +45,11 @@ public int main (string[] args) {
 	var ss2 = ss.ref ();
 	stdout.printf ("shared rstring 2: %s\n", ss2.get ());
 
+	try {
+		throw_err();
+		assert_not_reached();
+	} catch (Ex.Error e) {
+		assert_error(e, Ex.Error.quark(), Ex.Error.FAILED);
+	}
 	return 0;
 }