Add ErrorMessage type

This can be used to propagate an element error via a Result until the
place where it can be actually posted on an element.

gstreamer/src/element.rs

@@ -116,6 +116,8 @@ pub trait ElementExtManual {
         structure: ::Structure,
     );
 
+    fn post_error_message(&self, msg: &::ErrorMessage);
+
     fn iterate_pads(&self) -> ::Iterator<Pad>;
     fn iterate_sink_pads(&self) -> ::Iterator<Pad>;
     fn iterate_src_pads(&self) -> ::Iterator<Pad>;
@@ -295,6 +297,32 @@ impl<O: IsA<Element>> ElementExtManual for O {
         }
     }
 
+    fn post_error_message(&self, msg: &::ErrorMessage) {
+        let ::ErrorMessage {
+            error_domain,
+            error_code,
+            ref message,
+            ref debug,
+            filename,
+            function,
+            line,
+        } = *msg;
+
+        unsafe {
+            ffi::gst_element_message_full(
+                self.to_glib_none().0,
+                ffi::GST_MESSAGE_ERROR,
+                error_domain,
+                error_code,
+                message.to_glib_full(),
+                debug.to_glib_full(),
+                filename.to_glib_none().0,
+                function.to_glib_none().0,
+                line as i32,
+            );
+        }
+    }
+
     fn iterate_pads(&self) -> ::Iterator<Pad> {
         unsafe { from_glib_full(ffi::gst_element_iterate_pads(self.to_glib_none().0)) }
     }

gstreamer/src/error.rs

@@ -0,0 +1,109 @@
+// Copyright (C) 2016-2017 Sebastian Dröge <sebastian@centricular.com>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::error::Error;
+use std::fmt;
+
+use glib_ffi;
+
+#[macro_export]
+macro_rules! gst_error_msg(
+// Plain strings
+    ($err:expr, ($msg:expr), [$dbg:expr]) =>  {
+        $crate::ErrorMessage::new(&$err, Some($msg),
+                          Some($dbg),
+                          file!(), module_path!(), line!())
+    };
+    ($err:expr, ($msg:expr)) => {
+        $crate::ErrorMessage::new(&$err, Some($msg),
+                          None,
+                          file!(), module_path!(), line!())
+    };
+    ($err:expr, [$dbg:expr]) => {
+        $crate::ErrorMessage::new(&$err, None,
+                          Some($dbg),
+                          file!(), module_path!(), line!())
+    };
+
+// Format strings
+    ($err:expr, ($($msg:tt)*), [$($dbg:tt)*]) =>  { {
+        $crate::ErrorMessage::new(&$err, Some(format!($($msg)*).as_ref()),
+                          Some(format!($($dbg)*).as_ref()),
+                          file!(), module_path!(), line!())
+    }};
+    ($err:expr, ($($msg:tt)*)) =>  { {
+        $crate::ErrorMessage::new(&$err, Some(format!($($msg)*).as_ref()),
+                          None,
+                          file!(), module_path!(), line!())
+    }};
+
+    ($err:expr, [$($dbg:tt)*]) =>  { {
+        $crate::ErrorMessage::new(&$err, None,
+                          Some(format!($($dbg)*).as_ref()),
+                          file!(), module_path!(), line!())
+    }};
+);
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ErrorMessage {
+    pub(crate) error_domain: glib_ffi::GQuark,
+    pub(crate) error_code: i32,
+    pub(crate) message: Option<String>,
+    pub(crate) debug: Option<String>,
+    pub(crate) filename: &'static str,
+    pub(crate) function: &'static str,
+    pub(crate) line: u32,
+}
+
+impl ErrorMessage {
+    pub fn new<
+        'a,
+        'b,
+        T: ::MessageErrorDomain,
+        U: Into<Option<&'a str>>,
+        V: Into<Option<&'b str>>,
+    >(
+        error: &T,
+        message: U,
+        debug: V,
+        filename: &'static str,
+        function: &'static str,
+        line: u32,
+    ) -> ErrorMessage {
+        let domain = T::domain();
+        let code = error.code();
+        let message = message.into();
+        let debug = debug.into();
+
+        ErrorMessage {
+            error_domain: domain,
+            error_code: code,
+            message: message.map(String::from),
+            debug: debug.map(String::from),
+            filename: filename,
+            function: function,
+            line: line,
+        }
+    }
+}
+
+impl fmt::Display for ErrorMessage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(
+            f,
+            "Error {:?} ({:?}) at {}:{}",
+            self.message, self.debug, self.filename, self.line
+        )
+    }
+}
+
+impl Error for ErrorMessage {
+    fn description(&self) -> &str {
+        "ErrorMessage"
+    }
+}

gstreamer/src/lib.rs

@@ -63,6 +63,10 @@ pub use auto::functions::*;
 mod log;
 pub use log::*;
 
+#[macro_use]
+mod error;
+pub use error::*;
+
 pub mod miniobject;
 pub use miniobject::{GstRc, MiniObject};
 pub mod message;